diff options
Diffstat (limited to '')
55 files changed, 2649 insertions, 1685 deletions
diff --git a/sca-cpp/trunk/components/cache/mcache-client-test.cpp b/sca-cpp/trunk/components/cache/mcache-client-test.cpp index 2e444250c7..e3bf5f7a2e 100644 --- a/sca-cpp/trunk/components/cache/mcache-client-test.cpp +++ b/sca-cpp/trunk/components/cache/mcache-client-test.cpp @@ -24,8 +24,8 @@ */ #include <assert.h> -#include <iostream> -#include <string> +#include "stream.hpp" +#include "string.hpp" #include "list.hpp" #include "value.hpp" @@ -36,46 +36,46 @@ namespace tuscany { namespace cache { -const std::string url("http://localhost:8090/mcache"); +const string url("http://localhost:8090/mcache"); bool testCache() { http::CURLSession cs; const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$2.99")); - const list<value> a = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const list<value> a = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); - const failable<value, std::string> id = http::post(a, url, cs); + const failable<value> id = http::post(a, url, cs); assert(hasContent(id)); { - const failable<value, std::string> val = http::get(url + "/" + std::string(content(id)), cs); + const failable<value> val = http::get(url + "/" + content(id), cs); assert(hasContent(val)); assert(content(val) == a); } const list<value> j = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$3.55")); - const list<value> b = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), j); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$3.55")); + const list<value> b = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), j); { - const failable<value, std::string> r = http::put(b, url + "/" + std::string(content(id)), cs); + const failable<value> r = http::put(b, url + "/" + content(id), cs); assert(hasContent(r)); assert(content(r) == value(true)); } { - const failable<value, std::string> val = http::get(url + "/" + std::string(content(id)), cs); + const failable<value> val = http::get(url + "/" + content(id), cs); assert(hasContent(val)); assert(content(val) == b); } { - const failable<value, std::string> r = http::del(url + "/" + std::string(content(id)), cs); + const failable<value> r = http::del(url + "/" + content(id), cs); assert(hasContent(r)); assert(content(r) == value(true)); } { - const failable<value, std::string> val = http::get(url + "/" + std::string(content(id)), cs); + const failable<value> val = http::get(url + "/" + content(id), cs); assert(!hasContent(val)); } @@ -89,7 +89,7 @@ struct getLoop { getLoop(const value& id, const value& entry, http::CURLSession cs) : id(id), entry(entry), cs(cs) { } const bool operator()() const { - const failable<value, std::string> val = http::get(url + "/" + std::string(id), cs); + const failable<value> val = http::get(url + "/" + id, cs); assert(hasContent(val)); assert(content(val) == entry); return true; @@ -98,16 +98,16 @@ struct getLoop { bool testGetPerf() { const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$4.55")); - const value a = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$4.55")); + const value a = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); http::CURLSession cs; - const failable<value, std::string> id = http::post(a, url, cs); + const failable<value> id = http::post(a, url, cs); assert(hasContent(id)); const lambda<bool()> gl = getLoop(content(id), a, cs); - std::cout << "Cache get test " << time(gl, 5, 200) << " ms" << std::endl; + cout << "Cache get test " << time(gl, 5, 200) << " ms" << endl; return true; } @@ -116,12 +116,12 @@ bool testGetPerf() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::cache::testCache(); tuscany::cache::testGetPerf(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/components/cache/mcache-test.cpp b/sca-cpp/trunk/components/cache/mcache-test.cpp index dc286687c0..90f17ffd48 100644 --- a/sca-cpp/trunk/components/cache/mcache-test.cpp +++ b/sca-cpp/trunk/components/cache/mcache-test.cpp @@ -24,8 +24,8 @@ */ #include <assert.h> -#include <iostream> -#include <string> +#include "stream.hpp" +#include "string.hpp" #include "perf.hpp" #include "mcache.hpp" @@ -35,10 +35,10 @@ namespace cache { bool testMemCached() { MemCached ch; - assert(hasContent(post("a", std::string("AAA"), ch))); - assert(get("a", ch) == value(std::string("AAA"))); - assert(hasContent(put("a", std::string("aaa"), ch))); - assert(get("a", ch) == value(std::string("aaa"))); + assert(hasContent(post("a", string("AAA"), ch))); + assert((get("a", ch)) == value(string("AAA"))); + assert(hasContent(put("a", string("aaa"), ch))); + assert((get("a", ch)) == value(string("aaa"))); assert(hasContent(del("a", ch))); assert(!hasContent(get("a", ch))); @@ -50,18 +50,17 @@ struct getLoop { getLoop(MemCached& ch) : ch(ch) { } const bool operator()() const { - assert(get("c", ch) == value(std::string("CCC"))); + assert((get("c", ch)) == value(string("CCC"))); return true; } }; bool testGetPerf() { MemCached ch; - assert(hasContent(post("c", std::string("CCC"), ch))); + assert(hasContent(post("c", string("CCC"), ch))); const lambda<bool()> gl = getLoop(ch); - std::cout << "Memcached get test " << time(gl, 5, 200) << " ms" << std::endl; - + cout << "Memcached get test " << time(gl, 5, 200) << " ms" << endl; return true; } @@ -69,12 +68,12 @@ bool testGetPerf() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::cache::testMemCached(); tuscany::cache::testGetPerf(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/components/cache/mcache.cpp b/sca-cpp/trunk/components/cache/mcache.cpp index 926fb66674..3e8fdeb294 100644 --- a/sca-cpp/trunk/components/cache/mcache.cpp +++ b/sca-cpp/trunk/components/cache/mcache.cpp @@ -25,7 +25,7 @@ #include <apr_uuid.h> -#include <string> +#include "string.hpp" #include "function.hpp" #include "list.hpp" @@ -41,7 +41,7 @@ cache::MemCached ch; /** * Get an item from the cache. */ -const failable<value, std::string> get(const list<value>& params) { +const failable<value> get(const list<value>& params) { return cache::get(car(params), ch); } @@ -53,34 +53,34 @@ const value uuidValue() { apr_uuid_get(&uuid); char buf[APR_UUID_FORMATTED_LENGTH]; apr_uuid_format(buf, &uuid); - return value(std::string(buf, APR_UUID_FORMATTED_LENGTH)); + return value(string(buf, APR_UUID_FORMATTED_LENGTH)); } -const failable<value, std::string> post(const list<value>& params) { +const failable<value> post(const list<value>& params) { const value id = uuidValue(); - const failable<bool, std::string> val = cache::post(id, car(params), ch); + const failable<bool> val = cache::post(id, car(params), ch); if (!hasContent(val)) - return mkfailure<value, std::string>(reason(val)); + return mkfailure<value>(reason(val)); return id; } /** * Put an item into the cache. */ -const failable<value, std::string> put(const list<value>& params) { - const failable<bool, std::string> val = cache::put(car(params), cadr(params), ch); +const failable<value> put(const list<value>& params) { + const failable<bool> val = cache::put(car(params), cadr(params), ch); if (!hasContent(val)) - return mkfailure<value, std::string>(reason(val)); + return mkfailure<value>(reason(val)); return value(content(val)); } /** * Delete an item from the cache. */ -const failable<value, std::string> del(const list<value>& params) { - const failable<bool, std::string> val = cache::del(car(params), ch); +const failable<value> del(const list<value>& params) { + const failable<bool> val = cache::del(car(params), ch); if (!hasContent(val)) - return mkfailure<value, std::string>(reason(val)); + return mkfailure<value>(reason(val)); return value(content(val)); } @@ -99,7 +99,7 @@ const tuscany::value eval(const tuscany::list<tuscany::value>& params) { return tuscany::cache::put(cdr(params)); if (func == "delete") return tuscany::cache::del(cdr(params)); - return tuscany::mkfailure<tuscany::value, std::string>(std::string("Function not supported: ") + std::string(func)); + return tuscany::mkfailure<tuscany::value>(tuscany::string("Function not supported: ") + func); } } diff --git a/sca-cpp/trunk/components/cache/mcache.hpp b/sca-cpp/trunk/components/cache/mcache.hpp index d1fe182946..3f32a47964 100644 --- a/sca-cpp/trunk/components/cache/mcache.hpp +++ b/sca-cpp/trunk/components/cache/mcache.hpp @@ -34,8 +34,7 @@ #include "apr_memcache.h" #include "apr_network_io.h" -#include <string> -#include <sstream> +#include "string.hpp" #include "list.hpp" #include "value.hpp" #include "monad.hpp" @@ -56,7 +55,7 @@ public: init("localhost", 11211); } - MemCached(const std::string host, const int port) { + MemCached(const string host, const int port) { apr_pool_create(&pool, NULL); apr_memcache_create(pool, 1, 0, &mc); init(host, port); @@ -70,22 +69,22 @@ private: apr_pool_t* pool; apr_memcache_t* mc; - friend const failable<bool, std::string> post(const value& key, const value& val, const MemCached& cache); - friend const failable<bool, std::string> put(const value& key, const value& val, const MemCached& cache); - friend const failable<value, std::string> get(const value& key, const MemCached& cache); - friend const failable<bool, std::string> del(const value& key, const MemCached& cache); + friend const failable<bool> post(const value& key, const value& val, const MemCached& cache); + friend const failable<bool> put(const value& key, const value& val, const MemCached& cache); + friend const failable<value> get(const value& key, const MemCached& cache); + friend const failable<bool> del(const value& key, const MemCached& cache); /** * Initialize the memcached context. */ - const failable<bool, std::string> init(const std::string& host, const int port) { + const failable<bool> init(const string& host, const int port) { apr_memcache_server_t *server; - const apr_status_t sc = apr_memcache_server_create(pool, host.c_str(), (apr_port_t)port, 0, 1, 1, 60, &server); + const apr_status_t sc = apr_memcache_server_create(pool, c_str(host), (apr_port_t)port, 0, 1, 1, 60, &server); if (sc != APR_SUCCESS) - return mkfailure<bool, std::string>("Could not create server"); + return mkfailure<bool>("Could not create server"); const apr_status_t as = apr_memcache_add_server(mc, server); if (as != APR_SUCCESS) - return mkfailure<bool, std::string>("Could not add server"); + return mkfailure<bool>("Could not add server"); return true; } @@ -94,15 +93,15 @@ private: /** * Post a new item to the cache. */ -const failable<bool, std::string> post(const value& key, const value& val, const MemCached& cache) { +const failable<bool> post(const value& key, const value& val, const MemCached& cache) { debug(key, "cache::post::key"); debug(val, "cache::post::value"); - const std::string ks(eval::writeValue(key)); - const std::string vs(eval::writeValue(val)); - const apr_status_t rc = apr_memcache_add(cache.mc, ks.c_str(), const_cast<char*>(vs.c_str()), vs.size(), 0, 27); + const string ks(eval::writeValue(key)); + const string vs(eval::writeValue(val)); + const apr_status_t rc = apr_memcache_add(cache.mc, c_str(ks), const_cast<char*>(c_str(vs)), length(vs), 0, 27); if (rc != APR_SUCCESS) - return mkfailure<bool, std::string>("Could not add entry"); + return mkfailure<bool>("Could not add entry"); debug(true, "cache::post::result"); return true; @@ -111,15 +110,15 @@ const failable<bool, std::string> post(const value& key, const value& val, const /** * Update an item in the cache. If the item doesn't exist it is added. */ -const failable<bool, std::string> put(const value& key, const value& val, const MemCached& cache) { +const failable<bool> put(const value& key, const value& val, const MemCached& cache) { debug(key, "cache::put::key"); debug(val, "cache::put::value"); - const std::string ks(eval::writeValue(key)); - const std::string vs(eval::writeValue(val)); - const apr_status_t rc = apr_memcache_set(cache.mc, ks.c_str(), const_cast<char*>(vs.c_str()), vs.size(), 0, 27); + const string ks(eval::writeValue(key)); + const string vs(eval::writeValue(val)); + const apr_status_t rc = apr_memcache_set(cache.mc, c_str(ks), const_cast<char*>(c_str(vs)), length(vs), 0, 27); if (rc != APR_SUCCESS) - return mkfailure<bool, std::string>("Could not add entry"); + return mkfailure<bool>("Could not add entry"); debug(true, "cache::put::result"); return true; @@ -128,25 +127,24 @@ const failable<bool, std::string> put(const value& key, const value& val, const /** * Get an item from the cache. */ -const failable<value, std::string> get(const value& key, const MemCached& cache) { +const failable<value> get(const value& key, const MemCached& cache) { debug(key, "cache::get::key"); - const std::string ks(eval::writeValue(key)); - + const string ks(eval::writeValue(key)); apr_pool_t* vpool; const apr_status_t pc = apr_pool_create(&vpool, cache.pool); if (pc != APR_SUCCESS) - return mkfailure<value, std::string>("Could not allocate memory"); + return mkfailure<value>("Could not allocate memory"); char *data; apr_size_t size; - const apr_status_t rc = apr_memcache_getp(cache.mc, cache.pool, ks.c_str(), &data, &size, NULL); + const apr_status_t rc = apr_memcache_getp(cache.mc, cache.pool, c_str(ks), &data, &size, NULL); if (rc != APR_SUCCESS) { apr_pool_destroy(vpool); - return mkfailure<value, std::string>("Could not get entry"); + return mkfailure<value>("Could not get entry"); } - const value val(eval::readValue(std::string(data, size))); + const value val(eval::readValue(string(data, size))); apr_pool_destroy(vpool); debug(val, "cache::get::result"); @@ -156,14 +154,13 @@ const failable<value, std::string> get(const value& key, const MemCached& cache) /** * Delete an item from the cache */ -const failable<bool, std::string> del(const value& key, const MemCached& cache) { +const failable<bool> del(const value& key, const MemCached& cache) { debug(key, "cache::delete::key"); - std::ostringstream kos; - kos << key; - const apr_status_t rc = apr_memcache_delete(cache.mc, kos.str().c_str(), 0); + const string ks(eval::writeValue(key)); + const apr_status_t rc = apr_memcache_delete(cache.mc, c_str(ks), 0); if (rc != APR_SUCCESS) - return mkfailure<bool, std::string>("Could not delete entry"); + return mkfailure<bool>("Could not delete entry"); debug(true, "cache::delete::result"); return true; diff --git a/sca-cpp/trunk/components/cache/memcached-server-test b/sca-cpp/trunk/components/cache/memcached-server-test index 0dc32f6613..f3c4287dc8 100755 --- a/sca-cpp/trunk/components/cache/memcached-server-test +++ b/sca-cpp/trunk/components/cache/memcached-server-test @@ -35,7 +35,7 @@ $mc & sleep 2 # Test -./mcache-client-test 2>/dev/null +./mcache-client-test rc=$? # Cleanup diff --git a/sca-cpp/trunk/components/cache/memcached-test b/sca-cpp/trunk/components/cache/memcached-test index 0160188f65..df21d32a57 100755 --- a/sca-cpp/trunk/components/cache/memcached-test +++ b/sca-cpp/trunk/components/cache/memcached-test @@ -23,7 +23,7 @@ $mc & sleep 1 # Test -./mcache-test 2>/dev/null +./mcache-test rc=$? # Cleanup diff --git a/sca-cpp/trunk/configure.ac b/sca-cpp/trunk/configure.ac index af2dcf4df6..99650734c3 100644 --- a/sca-cpp/trunk/configure.ac +++ b/sca-cpp/trunk/configure.ac @@ -39,7 +39,7 @@ AC_PROG_LIBTOOL # Check for running on Darwin AC_MSG_CHECKING([if running on Darwin]) UNAME=`uname -s` -if test "x$UNAME" = "xDarwin"; then +if test "${UNAME}" = "Darwin"; then AC_DEFINE([IS_DARWIN], [1], [Set to 1 when running on Darwin - Mac OSX]) AC_MSG_RESULT(yes) AC_SUBST([libsuffix],[".dylib"]) @@ -49,14 +49,14 @@ else AC_SUBST([libsuffix],[".so"]) is_darwin=false fi -AM_CONDITIONAL([DARWIN], [test x$is_darmin = xtrue]) +AM_CONDITIONAL([DARWIN], [test "${is_darmin}" = "true"]) # Configure CURL_INCLUDE and CURL_LIB AC_MSG_CHECKING([for curl]) AC_ARG_WITH([curl], [AC_HELP_STRING([--with-curl=PATH], [path to installed curl [default=/usr]])], [ - CURL_INCLUDE="$withval/include" - CURL_LIB="$withval/lib" - AC_MSG_RESULT("$withval") + CURL_INCLUDE="${withval}/include" + CURL_LIB="${withval}/lib" + AC_MSG_RESULT("${withval}") ], [ CURL_INCLUDE="/usr/include" CURL_LIB="/usr/lib" @@ -68,9 +68,9 @@ AC_SUBST(CURL_LIB) # Configure LIBXML2_INCLUDE and LIBXML2_LIB AC_MSG_CHECKING([for libxml2]) AC_ARG_WITH([libxml2], [AC_HELP_STRING([--with-libxml2=PATH], [path to installed libxml2 [default=/usr]])], [ - LIBXML2_INCLUDE="$withval/include/libxml2" - LIBXML2_LIB="$withval/lib" - AC_MSG_RESULT("$withval") + LIBXML2_INCLUDE="${withval}/include/libxml2" + LIBXML2_LIB="${withval}/lib" + AC_MSG_RESULT("${withval}") ], [ LIBXML2_INCLUDE="/usr/include/libxml2" LIBXML2_LIB="/usr/lib" @@ -83,16 +83,16 @@ AC_SUBST(LIBXML2_LIB) AC_MSG_CHECKING([for js-include]) AC_ARG_WITH([js-include], [AC_HELP_STRING([--with-js-include=PATH], [path to installed SpiderMonkey include dir [default=/usr/include/xulrunner-1.9.1.5/unstable]])], [ - JS_INCLUDE="$withval" - AC_MSG_RESULT("$withval") + JS_INCLUDE="${withval}" + AC_MSG_RESULT("${withval}") ], [ JS_INCLUDE="/usr/include/xulrunner-1.9.1.5/unstable" AC_MSG_RESULT(/usr/include/xulrunner-1.9.1.5/unstable) ]) AC_MSG_CHECKING([for js-lib]) AC_ARG_WITH([js-lib], [AC_HELP_STRING([--with-js-lib=PATH], [path to installed SpiderMonkey lib dir [default=/usr/lib/xulrunner-1.9.1.5]])], [ - JS_LIB="$withval" - AC_MSG_RESULT("$withval") + JS_LIB="${withval}" + AC_MSG_RESULT("${withval}") ], [ JS_LIB="/usr/lib/xulrunner-1.9.1.5" AC_MSG_RESULT(/usr/lib/xulrunner-1.9.1.5) @@ -103,9 +103,9 @@ AC_SUBST(JS_LIB) # Configure APR and HTTPD AC_MSG_CHECKING([for apr]) AC_ARG_WITH([apr], [AC_HELP_STRING([--with-apr=PATH], [path to installed apr [default=/usr/local/apache2]])], [ - APR_INCLUDE="$withval/include" - APR_LIB="$withval/lib" - AC_MSG_RESULT("$withval") + APR_INCLUDE="${withval}/include" + APR_LIB="${withval}/lib" + AC_MSG_RESULT("${withval}") ], [ APR_INCLUDE="/usr/local/apache2/include" APR_LIB="/usr/local/apache2/lib" @@ -116,8 +116,8 @@ AC_SUBST(APR_LIB) AC_MSG_CHECKING([for httpd]) AC_ARG_WITH([httpd], [AC_HELP_STRING([--with-httpd=PATH], [path to installed httpd [default=/usr/local/apache2]])], [ - HTTPD_INCLUDE="$withval/include" - AC_MSG_RESULT("$withval") + HTTPD_INCLUDE="${withval}/include" + AC_MSG_RESULT("${withval}") ], [ HTTPD_INCLUDE="/usr/local/apache2/include" AC_MSG_RESULT(/usr/local/apache2/lib) @@ -125,20 +125,20 @@ AC_ARG_WITH([httpd], [AC_HELP_STRING([--with-httpd=PATH], [path to installed htt AC_SUBST(HTTPD_INCLUDE) # Checks for libraries. -original_LIBS="$LIBS" +original_LIBS="${LIBS}" AC_MSG_NOTICE([checking for libraries]) -LIBS="-L$CURL_LIB $original_LIBS" +LIBS="-L${CURL_LIB} ${original_LIBS}" AC_CHECK_LIB([curl], [curl_global_init], [], [AC_MSG_ERROR([couldn't find a suitable libcurl, use --with-curl=PATH])]) -LIBS="-L$JS_LIB $original_LIBS" +LIBS="-L${JS_LIB} ${original_LIBS}" AC_CHECK_LIB([mozjs], [JS_NewContext], [], [AC_MSG_ERROR([couldn't find a suitable libmozjs, use --with-js-lib=PATH])]) -LIBS="$original_LIBS" +LIBS="${original_LIBS}" AC_CHECK_LIB([pthread], [pthread_create], [], [AC_MSG_ERROR([couldn't find a suitable libpthread])]) -LIBS="-L$LIBXML2_LIB $original_LIBS" +LIBS="-L${LIBXML2_LIB} ${original_LIBS}" AC_CHECK_LIB([xml2], [xmlInitParser], [], [AC_MSG_ERROR([couldn't find a suitable libxml2, use --with-libxml2=PATH])]) -LIBS="-L$APR_LIB $original_LIBS" +LIBS="-L${APR_LIB} ${original_LIBS}" AC_CHECK_LIB([apr-1], [apr_pool_initialize], [], [AC_MSG_ERROR([couldn't find a suitable libapr-1, use --with-apr=PATH])]) AC_CHECK_LIB([aprutil-1], [apr_memcache_replace], [], [AC_MSG_ERROR([couldn't find a suitable libaprutil-1, use --with-apr=PATH])]) -LIBS="$original_LIBS" +LIBS="${original_LIBS}" # Checks for header files. AC_MSG_NOTICE([checking for header files]) @@ -158,9 +158,12 @@ AC_MSG_NOTICE([checking for library functions]) AC_CHECK_FUNCS([gettimeofday select]) # Configure GCC C++ compile options -# Configure debugging, profiling and compile-time warnings -AC_MSG_CHECKING([whether to compile for debugging and profiling]) -AC_ARG_ENABLE(maintainer-mode, [AS_HELP_STRING([--enable-maintainer-mode], [compile for debugging and profiling [default=no]])], +cxxflags="" +ldflags="${LDFLAGS}" + +# Configure debugging and compile-time warnings +AC_MSG_CHECKING([whether to compile with debugging and compile-time warnings]) +AC_ARG_ENABLE(maintainer-mode, [AS_HELP_STRING([--enable-maintainer-mode], [compile with debugging and compile-time warnings [default=no]])], [ case "${enableval}" in no) AC_MSG_RESULT(no) @@ -171,23 +174,63 @@ AC_ARG_ENABLE(maintainer-mode, [AS_HELP_STRING([--enable-maintainer-mode], [comp ;; esac ], [ AC_MSG_RESULT(no)]) -if test "$want_maintainer_mode" = "true"; then - AC_SUBST([CXXFLAGS], [" -D_REENTRANT -D_DEBUG -O0 -g3 -pg -Werror -Wall -Wextra -Wno-ignored-qualifiers -Winit-self -Wmissing-include-dirs -Wcast-qual -Wcast-align -Wwrite-strings -Wpointer-arith -Wconversion -Waddress -Wlogical-op -Wredundant-decls -std=c++0x -fmessage-length=0"]) - AC_SUBST([LDFLAGS], ["${LDFLAGS} -lpthread -pg"]) +if test "${want_maintainer_mode}" = "true"; then + cxxflags="${cxxflags} -D_DEBUG -O0 -g3 -Werror -Wall -Wextra -Wno-ignored-qualifiers -Winit-self -Wmissing-include-dirs -Wcast-qual -Wcast-align -Wwrite-strings -Wpointer-arith -Wconversion -Waddress -Wlogical-op -Wredundant-decls -std=c++0x -fmessage-length=0" + ldflags="${ldflags} -pg" else - AC_SUBST([CXXFLAGS], [" -D_REENTRANT -O3 -std=c++0x -fmessage-length=0"]) - AC_SUBST([LDFLAGS], ["${LDFLAGS} -lpthread"]) + cxxflags="${cxxflags} -O3 -std=c++0x -fmessage-length=0" +fi + +# Configure profiling +AC_MSG_CHECKING([whether to compile with profiling]) +AC_ARG_ENABLE(profiling, [AS_HELP_STRING([--enable-profiling], [compile with profiling [default=no]])], +[ case "${enableval}" in + no) + AC_MSG_RESULT(no) + ;; + *) + AC_MSG_RESULT(yes) + want_profiling=true + ;; + esac ], +[ AC_MSG_RESULT(no)]) +if test "${want_profiling}" = "true"; then + cxxflags="${cxxflags} -pg" + ldflags="${ldflags} -pg" +fi + +# Configure multi-threading support +AC_MSG_CHECKING([whether to compile for multi-threaded execution]) +AC_ARG_ENABLE(threads, [AS_HELP_STRING([--enable-threads], [compile for multi-threaded execution [default=no]])], +[ case "${enableval}" in + no) + AC_MSG_RESULT(no) + ;; + *) + AC_MSG_RESULT(yes) + want_threads=true + ;; + esac ], +[ AC_MSG_RESULT(no)]) +if test "${want_threads}" = "true"; then + LIBS="${original_LIBS}" + AC_CHECK_LIB([pthread], [pthread_create], [], [AC_MSG_ERROR([couldn't find a suitable libpthread])]) + LIBS="${original_LIBS}" + cxxflags="${cxxflags} -D_REENTRANT" + ldflags="${ldflags} -lpthread" fi +AC_SUBST([CXXFLAGS], ["${cxxflags}"]) +AC_SUBST([LDFLAGS], ["${ldflags}"]) # Configure exuberant ctags TAGSFILE="`pwd`/tags" -AC_SUBST([CTAGSFLAGS], ["${CTAGSFLAGS} --c++-kinds=+p --fields=+iaS --extra=+q --append --tag-relative=yes -f $TAGSFILE"]) +AC_SUBST([CTAGSFLAGS], ["${CTAGSFLAGS} --c++-kinds=+p --fields=+iaS --extra=+q --append --tag-relative=yes -f ${TAGSFILE}"]) # Configure TUSCANY_SCACPP -TUSCANY_SCACPP=`echo "$TUSCANY_SCACPP"` -if test "$TUSCANY_SCACPP" = ""; then +TUSCANY_SCACPP=`echo "${TUSCANY_SCACPP}"` +if test "${TUSCANY_SCACPP}" = ""; then SCAPWD=`pwd` - AC_SUBST([TUSCANY_SCACPP], ["$SCAPWD"]) + AC_SUBST([TUSCANY_SCACPP], ["${SCAPWD}"]) fi # Configure Doxygen build @@ -199,15 +242,15 @@ AC_ARG_ENABLE(doxygen, [AS_HELP_STRING([--enable-doxygen], [build Doxygen docume ;; *) AC_MSG_RESULT(yes) - AC_PATH_PROG(DOXYGEN, doxygen, , $PATH) - if test "$DOXYGEN" = ""; then + AC_PATH_PROG(DOXYGEN, doxygen, , ${PATH}) + if test "${DOXYGEN}" = ""; then AC_MSG_ERROR([could not find doxygen]) fi want_doxygen=true ;; esac ], [ AC_MSG_RESULT(no)]) -AM_CONDITIONAL([WANT_DOXYGEN], [test "$want_doxygen" = "true"]) +AM_CONDITIONAL([WANT_DOXYGEN], [test "${want_doxygen}" = "true"]) AC_CONFIG_FILES([Makefile kernel/Makefile diff --git a/sca-cpp/trunk/etc/git-exclude b/sca-cpp/trunk/etc/git-exclude index 2e5c4821d0..d71d8e428b 100644 --- a/sca-cpp/trunk/etc/git-exclude +++ b/sca-cpp/trunk/etc/git-exclude @@ -61,17 +61,21 @@ doxygen # Specific ignores kernel-test -xsd-test -parallel-test +string-test +mem-test xml-test +xsd-test atom-test eval-test eval-shell json-test +cache-test client-test mcache-test mcache-client-test curl-test scdl-test +store-function-test +store-object-test store-script-test diff --git a/sca-cpp/trunk/kernel/Makefile.am b/sca-cpp/trunk/kernel/Makefile.am index 4dfc285e90..507454439a 100644 --- a/sca-cpp/trunk/kernel/Makefile.am +++ b/sca-cpp/trunk/kernel/Makefile.am @@ -15,7 +15,7 @@ # specific language governing permissions and limitations # under the License. -noinst_PROGRAMS = kernel-test parallel-test xml-test xsd-test +noinst_PROGRAMS = string-test kernel-test mem-test parallel-test xml-test xsd-test testdir=$(prefix)/test test_LTLIBRARIES = libdynlib-test.la @@ -25,12 +25,18 @@ include_HEADERS = *.hpp INCLUDES = -I. -I$(top_builddir)/kernel -I${LIBXML2_INCLUDE} -I${APR_INCLUDE} -kernel_test_SOURCES = kernel-test.cpp -kernel_test_LDADD = -L${LIBXML2_LIB} -lxml2 -L${APR_LIB} -lapr-1 -laprutil-1 +string_test_SOURCES = string-test.cpp +string_test_LDADD = -L${LIBXML2_LIB} -lxml2 -L${APR_LIB} -lapr-1 -laprutil-1 libdynlib_test_la_SOURCES = dynlib-test.cpp libdynlib_test_la_LIBADD = -L${APR_LIB} -lapr-1 -laprutil-1 +kernel_test_SOURCES = kernel-test.cpp +kernel_test_LDADD = -L${LIBXML2_LIB} -lxml2 -L${APR_LIB} -lapr-1 -laprutil-1 + +mem_test_SOURCES = mem-test.cpp +mem_test_LDADD = -L${APR_LIB} -lapr-1 -laprutil-1 + parallel_test_SOURCES = parallel-test.cpp parallel_test_LDADD = -L${LIBXML2_LIB} -lxml2 -L${APR_LIB} -lapr-1 -laprutil-1 @@ -40,4 +46,4 @@ xml_test_LDADD = -L${LIBXML2_LIB} -lxml2 -L${APR_LIB} -lapr-1 -laprutil-1 xsd_test_SOURCES = xsd-test.cpp xsd_test_LDADD = -L${LIBXML2_LIB} -lxml2 -L${APR_LIB} -lapr-1 -laprutil-1 -TESTS = kernel-test parallel-test xml-test +TESTS = string-test kernel-test mem-test parallel-test xml-test diff --git a/sca-cpp/trunk/kernel/debug.hpp b/sca-cpp/trunk/kernel/debug.hpp index c06fe55f4a..c51ee6c974 100644 --- a/sca-cpp/trunk/kernel/debug.hpp +++ b/sca-cpp/trunk/kernel/debug.hpp @@ -23,24 +23,15 @@ #define tuscany_debug_hpp /** - * Functions to help log and debug. + * Debug functions and macros. */ -#include <string> -#include <ostream> - namespace tuscany { #ifdef _DEBUG -/** - * Debug log. - */ -template<typename V> const bool debug(const V& v, const std::string& msg) { - std::cerr << msg << ": " << v << std::endl; - return true; -} +//#define _DEBUG_WATCH /** * Increment / decrement a debug counter. @@ -55,20 +46,18 @@ bool debug_dec(long int& c) { return true; } -/** - * Attribute used to mark unused parameters. - */ -#define unused __attribute__ ((unused)) - #else -#define debug(v, msg) - #define debug_inc(c) #define debug_dec(c) -#define unused +#endif +/** + * Attribute used to mark unused parameters. + */ +#ifndef unused +#define unused __attribute__ ((unused)) #endif } diff --git a/sca-cpp/trunk/kernel/dynlib.hpp b/sca-cpp/trunk/kernel/dynlib.hpp index 10a5a030cb..a000653455 100644 --- a/sca-cpp/trunk/kernel/dynlib.hpp +++ b/sca-cpp/trunk/kernel/dynlib.hpp @@ -38,9 +38,9 @@ namespace tuscany { * OS specific dynamic library file extension. */ #ifdef IS_DARWIN -const std::string dynlibExt(".dylib"); +const string dynlibExt(".dylib"); #else -const std::string dynlibExt(".so"); +const string dynlibExt(".so"); #endif /** @@ -51,7 +51,7 @@ public: lib() : dl(NULL) { } - lib(const std::string& name) : dl(new DynLib(name)) { + lib(const string& name) : dl(new (gc_new<DynLib>()) DynLib(name)) { } ~lib() { @@ -60,41 +60,42 @@ public: private: class DynLib { public: - DynLib(const std::string& name) : name(name), h(dlopen(name.c_str(), RTLD_NOW)) { + DynLib(const string& name) : name(name), h(dlopen(c_str(name), RTLD_NOW)) { } + ~DynLib() { if (h == NULL) return; dlclose(h); } - const std::string name; + const string name; void* h; }; gc_ptr<DynLib> dl; - friend const failable<lib, std::string> dynlib(const std::string& name); - template<typename S> friend const failable<lambda<S>, std::string> dynlambda(const std::string& name, const lib& l); + friend const failable<lib> dynlib(const string& name); + template<typename S> friend const failable<lambda<S> > dynlambda(const string& name, const lib& l); }; /** * Load a dynamic library. */ -const failable<lib, std::string> dynlib(const std::string& name) { +const failable<lib> dynlib(const string& name) { const lib l(name); if (l.dl->h == NULL) - return mkfailure<lib, std::string>("Could not load library: " + name + ": " + dlerror()); + return mkfailure<lib>(string("Could not load library: ") + name + ": " + dlerror()); return l; } /** * Find a lambda function in a dynamic library. */ -template<typename S> const failable<lambda<S>, std::string> dynlambda(const std::string& name, const lib& l) { - const void* s = dlsym(l.dl->h, name.c_str()); +template<typename S> const failable<lambda<S> > dynlambda(const string& name, const lib& l) { + const void* s = dlsym(l.dl->h, c_str(name)); if (s == NULL) - return mkfailure<lambda<S>, std::string>(std::string("Could not load symbol: " + name)); + return mkfailure<lambda<S> >(string("Could not load symbol: ") + name); return lambda<S>((S*)s); } diff --git a/sca-cpp/trunk/kernel/element.hpp b/sca-cpp/trunk/kernel/element.hpp index 612752d1df..4570110e96 100644 --- a/sca-cpp/trunk/kernel/element.hpp +++ b/sca-cpp/trunk/kernel/element.hpp @@ -98,7 +98,7 @@ const value elementHasValue(const list<value>& l) { const list<value> r = reverse(l); if (isSymbol(car(r))) return false; - if(isList(car(r)) && isSymbol(car<value>(car(r)))) + if(isList(car(r)) && !isNil((list<value>)car(r)) && isSymbol(car<value>(car(r)))) return false; return true; } @@ -201,7 +201,7 @@ const value valueToElement(const value& t) { return mklist(element, n, v); // Convert a list value - if (!isSymbol(car<value>(v))) + if (isNil((list<value>)v) || !isSymbol(car<value>(v))) return cons(element, cons(n, mklist<value>(valuesToElements(v)))); // Convert a nested name value pair value diff --git a/sca-cpp/trunk/kernel/fstream.hpp b/sca-cpp/trunk/kernel/fstream.hpp new file mode 100644 index 0000000000..3d6b1edade --- /dev/null +++ b/sca-cpp/trunk/kernel/fstream.hpp @@ -0,0 +1,152 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +/* $Rev$ $Date$ */ + +#ifndef tuscany_fstream_hpp +#define tuscany_fstream_hpp + +/** + * File based streams. + */ + +#include <stdio.h> +#include <stdarg.h> +#include "string.hpp" +#include "stream.hpp" + +namespace tuscany { + +/* + * Output stream backed by a FILE. + */ +class ofstream : public ostream { +public: + ofstream(const string& path) : file(fopen(c_str(path), "wb")), owned(true) { + } + + ofstream(FILE* file) : file(file), owned(false) { + } + + ofstream(const ofstream& os) : file(os.file), owned(false) { + } + + ~ofstream() { + if (!owned) + return; + if (file == NULL) + return; + fclose(file); + } + + ofstream& vprintf(const char* fmt, ...) { + va_list args; + va_start (args, fmt); + vfprintf (file, fmt, args); + va_end (args); + return *this; + } + + ofstream& flush() { + fflush(file); + return *this; + } + +private: + FILE* file; + bool owned; +}; + +/* + * Input stream backed by a FILE. + */ +class ifstream : public istream { +public: + ifstream(const string& path) : file(fopen(c_str(path), "rb")), owned(true) { + } + + ifstream(FILE* file) : file(file), owned(false) { + } + + ifstream(const ifstream& is) : file(is.file), owned(false) { + } + + ~ifstream() { + if (!owned) + return; + if (file == NULL) + return; + fclose(file); + } + + const int read(void* buf, int size) { + return fread(buf, 1, size, file); + } + + const bool eof() { + return feof(file); + } + + const bool fail() { + return file == NULL; + } + + const int get() { + return fgetc(file); + } + + const int peek() { + int c = fgetc(file); + if (c == -1) + return c; + ungetc(c, file); + return c; + } + +private: + FILE* file; + bool owned; +}; + +/** + * Standard streams. + */ +ofstream cout(stdout); +ofstream cerr(stderr); +ifstream cin(stdin); + +/** + * Debug log stream. + */ +#ifdef _DEBUG + +template<typename V> const bool debug(const V& v, const string& msg) { + cerr << msg << ": " << v << endl; + return true; +} + +#else + +#define debug(v, msg) + +#endif + +} + +#endif /* tuscany_fstream_hpp */ diff --git a/sca-cpp/trunk/kernel/function.hpp b/sca-cpp/trunk/kernel/function.hpp index 54784b5549..26f566fde6 100644 --- a/sca-cpp/trunk/kernel/function.hpp +++ b/sca-cpp/trunk/kernel/function.hpp @@ -26,7 +26,8 @@ * Lambda function type. */ -#include <iostream> +#include <bits/move.h> +#include "fstream.hpp" #include "gc.hpp" #include "debug.hpp" @@ -55,13 +56,13 @@ bool checkLambdaCounters() { } bool printLambdaCounters() { - std::cout << "countLambdas " << countLambdas << std::endl; - std::cout << "countELambdas " << countELambdas << std::endl; - std::cout << "countFLambdas " << countFLambdas << std::endl; - std::cout << "countCLambdas " << countCLambdas << std::endl; - std::cout << "countProxies " << countProxies << std::endl; - std::cout << "countFProxies " << countFProxies << std::endl; - std::cout << "countCProxies " << countCProxies << std::endl; + cout << "countLambdas " << countLambdas << endl; + cout << "countELambdas " << countELambdas << endl; + cout << "countFLambdas " << countFLambdas << endl; + cout << "countCLambdas " << countCLambdas << endl; + cout << "countProxies " << countProxies << endl; + cout << "countFProxies " << countFProxies << endl; + cout << "countCProxies " << countCProxies << endl; return true; } @@ -79,7 +80,7 @@ bool printLambdaCounters() { template<typename R, typename... P> class Callable { public: - Callable() : refCount(0) { + Callable() { } virtual const int size() const = 0; @@ -116,19 +117,6 @@ public: private: const F function; }; - -private: - friend class gc_counting_ptr<Callable>; - - unsigned int refCount; - - unsigned int acquire() { - return gc_add_and_fetch(refCount, (unsigned int)1); - } - - unsigned int release() { - return gc_sub_and_fetch(refCount, (unsigned int)1); - } }; template<typename S> class lambda; @@ -145,7 +133,7 @@ public: debug_inc(countFLambdas); typedef typename CallableType::template Proxy<F> ProxyType; - callable = gc_counting_ptr<CallableType>(new ProxyType(f)); + callable = gc_ptr<CallableType>(new (gc_new<ProxyType>()) ProxyType(f)); } lambda(const lambda& l) { @@ -179,15 +167,15 @@ public: return (*callable)(std::forward<P>(p)...); } - template<typename S> friend std::ostream& operator<<(std::ostream&, const lambda<S>&); + template<typename S> friend ostream& operator<<(ostream&, const lambda<S>&); template<typename S> friend const bool isNil(const lambda<S>& l); private: typedef Callable<R,P...> CallableType; - gc_counting_ptr<CallableType> callable; + gc_ptr<CallableType> callable; }; -template<typename S> std::ostream& operator<<(std::ostream& out, const lambda<S>& l) { +template<typename S> ostream& operator<<(ostream& out, const lambda<S>& l) { return out << "lambda::" << l.callable; } diff --git a/sca-cpp/trunk/kernel/gc.hpp b/sca-cpp/trunk/kernel/gc.hpp index c9a1a35756..3d20245c69 100644 --- a/sca-cpp/trunk/kernel/gc.hpp +++ b/sca-cpp/trunk/kernel/gc.hpp @@ -23,399 +23,236 @@ #define tuscany_gc_hpp /** - * Garbage collected pointer. + * Garbage collected memory management, using APR memory pools. */ +#include <stdlib.h> #include <apr_general.h> #include <apr_pools.h> -#include <iostream> +#include <assert.h> +#include <new> +#include "debug.hpp" namespace tuscany { /** - * Macros used to add or subtract values to reference counters. - * In a multithreaded environment, use the GCC __sync_add_and_fetch - * and __sync_sub_and_fetch built in functions. + * Pointer to a value. */ -#ifdef _REENTRANT - -#define gc_add_and_fetch(t, v) __sync_add_and_fetch(&(t), v) -#define gc_sub_and_fetch(t, v) __sync_sub_and_fetch(&(t), v) - -#else - -#define gc_add_and_fetch(t, v) ((t) = (t) + (v)) -#define gc_sub_and_fetch(t, v) ((t) = (t) - (v)) - -#endif - template<typename T> class gc_ptr { public: - gc_ptr(T* p = 0) throw() : countingRef(p == 0? 0 : new CountingRef(p)) { + gc_ptr(T* ptr = NULL) throw() : ptr(ptr) { } ~gc_ptr() throw() { - release(); } - gc_ptr(const gc_ptr& r) throw() : countingRef(r.countingRef) { - acquire(r.countingRef); + gc_ptr(const gc_ptr& r) throw() : ptr(r.ptr) { } gc_ptr& operator=(const gc_ptr& r) throw() { if(this == &r) return *this; - acquire(r.countingRef); - release(); - countingRef = r.countingRef; + ptr = r.ptr; return *this; } const bool operator==(const gc_ptr& r) const throw() { if (this == &r) return true; - if (countingRef == NULL) - return r.countingRef == NULL; - if (r.countingRef == NULL) - return false; - return countingRef-> ptr == r.countingRef->ptr; + return ptr == r.ptr; } const bool operator!=(const gc_ptr& r) const throw() { - return !this->operator ==(r); + return !this->operator==(r); } T& operator*() const throw() { - return *countingRef->ptr; + return *ptr; } T* operator->() const throw() { - return countingRef->ptr; + return ptr; } operator T*() const throw() { - return countingRef->ptr; - } - - template<typename X> friend std::ostream& operator<<(std::ostream&, const gc_ptr<X>&); - -private: - struct CountingRef { - T* ptr; - unsigned count; - - CountingRef(T* p) throw() : - ptr(p), count(1) { - } - }* countingRef; - - void acquire(CountingRef* ref) throw() { - if(ref) - gc_add_and_fetch(ref->count, (unsigned int)1); + return ptr; } - void release() throw() { - if(countingRef) { - unsigned rc = gc_sub_and_fetch(countingRef->count, (unsigned int)1); - if(rc == 0) { - delete countingRef->ptr; - delete countingRef; - } - } - } + T* ptr; }; -template<typename T> std::ostream& operator<<(std::ostream& out, const gc_ptr<T>& p) { - return out << p.countingRef->ptr; -} - /** - * Garbage collected pointer to an array. + * Garbage collected APR memory pool. */ -template<typename T> class gc_aptr { +class gc_pool { public: - gc_aptr(T* p = 0) throw() : countingRef(p == 0? 0 : new CountingRef(p)) { + gc_pool() : p(NULL) { } - ~gc_aptr() throw() { - release(); + gc_pool(apr_pool_t* p) : p(p) { } - gc_aptr(const gc_aptr& r) throw() : countingRef(r.countingRef) { - acquire(r.countingRef); + gc_pool(const gc_pool& pool) : p(pool.p) { } - gc_aptr& operator=(const gc_aptr& r) throw() { - if(this == &r) + gc_pool& operator=(const gc_pool& pool) { + if (this == &pool) return *this; - acquire(r.countingRef); - release(); - countingRef = r.countingRef; + p = pool.p; return *this; } - const bool operator==(const gc_aptr& r) const throw() { - if (this == &r) - return true; - if (countingRef == NULL) - return r.countingRef == NULL; - if (r.countingRef == NULL) - return false; - return countingRef-> ptr == r.countingRef->ptr; - } - - const bool operator!=(const gc_aptr& r) const throw() { - return !this->operator ==(r); - } - - T& operator*() const throw() { - return *countingRef->ptr; - } - - T* operator->() const throw() { - return countingRef->ptr; - } - - operator T*() const throw() { - return countingRef->ptr; + operator apr_pool_t*() const { + return p; } - template<typename X> friend std::ostream& operator<<(std::ostream&, const gc_aptr<X>&); - private: - struct CountingRef { - T* ptr; - unsigned count; - - CountingRef(T* p) throw() : - ptr(p), count(1) { - } - }* countingRef; - - void acquire(CountingRef* ref) throw() { - if(ref) - gc_add_and_fetch(ref->count, (unsigned int)1); - } + friend const bool destroy(gc_pool& pool); + friend class gc_global_pool_t; + friend class gc_scoped_pool; - void release() throw() { - if(countingRef) { - unsigned rc = gc_sub_and_fetch(countingRef->count, (unsigned int)1); - if(rc == 0) { - delete[] countingRef->ptr; - delete countingRef; - } - } - } + apr_pool_t* p; }; -template<typename T> std::ostream& operator<<(std::ostream& out, const gc_aptr<T>& p) { - return out << p.countingRef->ptr; -} - /** - * Garbage collected pointer to a reference counting object. + * Destroy a memory pool. */ -template<typename T> class gc_counting_ptr { -public: - gc_counting_ptr(T* p = 0) throw() : ptr(p) { - acquire(p); - } - - ~gc_counting_ptr() throw() { - release(); - } - - gc_counting_ptr(const gc_counting_ptr& r) throw() : ptr(r.ptr) { - acquire(ptr); - } - - gc_counting_ptr& operator=(const gc_counting_ptr& r) throw() { - if(this == &r) - return *this; - acquire(r.ptr); - release(); - ptr = r.ptr; - return *this; - } - - const bool operator==(const gc_counting_ptr& r) const throw() { - if (this == &r) - return true; - return ptr == r.ptr; - } - - const bool operator!=(const gc_counting_ptr& r) const throw() { - return !this->operator ==(r); - } - - T& operator*() const throw() { - return *ptr; - } - - T* operator->() const throw() { - return ptr; - } - - operator T*() const throw() { - return ptr; - } - - template<typename X> friend std::ostream& operator<<(std::ostream&, const gc_counting_ptr<X>&); - -private: - T* ptr; - - void acquire(T* p) throw() { - if(p) - p->acquire(); - } - - void release() throw() { - if(ptr) { - if(ptr->release() == 0) { - delete ptr; - } - } - } -}; - -template<typename T> std::ostream& operator<<(std::ostream& out, const gc_counting_ptr<T>& p) { - return out << p.ptr; +const bool destroy(gc_pool& pool) { + apr_pool_destroy(pool.p); + return true; } /** - * Apache Portable Runtime library context + * Default global memory pool. */ -class APRContext { +class gc_apr_context_t { public: - APRContext() { + gc_apr_context_t() { apr_initialize(); } - ~APRContext() { - apr_terminate(); + ~gc_apr_context_t() { + //apr_terminate(); } }; -APRContext aprContext; +gc_apr_context_t gc_apr_context; -/** - * Garbage collected memory pool, using an APR pool. - */ -class gc_pool { +class gc_global_pool_t : public gc_pool { public: - gc_pool() : aprPool(new APRPool) { + gc_global_pool_t() { + apr_pool_create(&p, NULL); } - operator apr_pool_t*() const { - return aprPool->p; + ~gc_global_pool_t() { + //apr_pool_destroy(p); } +}; -private: - class APRPool { - friend class gc_pool; - friend class gc_counting_ptr<APRPool>; - - unsigned int refCount; - apr_pool_t* p; - - APRPool() : refCount(0) { - apr_pool_create(&p, NULL); - } - - ~APRPool() { - apr_pool_destroy(p); - } - - unsigned int acquire() { - return gc_add_and_fetch(refCount, (unsigned int)1); - } +gc_global_pool_t gc_global_pool; - unsigned int release() { - return gc_sub_and_fetch(refCount, (unsigned int)1); - } - }; +/** + * Maintain a stack of memory pools. + */ +#ifdef _REENTRANT +__thread +#endif +apr_pool_t* gc_pool_stack = NULL; - const gc_counting_ptr<APRPool> aprPool; -}; +/** + * Return the current memory pool. + */ +apr_pool_t* gc_current_pool() { + apr_pool_t* p = gc_pool_stack; + if (p != NULL) + return p; + apr_pool_t* g = gc_global_pool; + gc_pool_stack = g; + return g; +} /** - * Garbage collected pointer to pooled memory. + * A memory pool scope, used to setup a scope in which a particular pool + * will be used for all allocations. */ -template<typename T> class gc_pool_ptr { +class gc_scoped_pool : public gc_pool { public: - gc_pool_ptr(T* ptr = 0) throw() : ptr(ptr) { - } - - ~gc_pool_ptr() throw() { - } - - gc_pool_ptr(const gc_pool_ptr& r) throw() : ptr(r.ptr) { - } - - gc_pool_ptr& operator=(const gc_pool_ptr& r) throw() { - if(this == &r) - return *this; - ptr = r.ptr; - return *this; - } - const bool operator==(const gc_pool_ptr& r) const throw() { - if (this == &r) - return true; - return ptr == r.ptr; - } - - const bool operator!=(const gc_pool_ptr& r) const throw() { - return !this->operator ==(r); + gc_scoped_pool() : gc_pool(NULL), prev(gc_current_pool()), owned(true) { + apr_pool_create(&p, NULL); + gc_pool_stack = p; } - T& operator*() const throw() { - return *ptr; + gc_scoped_pool(apr_pool_t* pool) : gc_pool(pool), prev(gc_current_pool()), owned(false) { + gc_pool_stack = p; } - T* operator->() const throw() { - return ptr; + ~gc_scoped_pool() { + if (owned) + apr_pool_destroy(p); + if (prev != NULL) + gc_pool_stack = prev; } - operator T*() const throw() { - return ptr; +private: + gc_scoped_pool(const unused gc_scoped_pool& pool) : gc_pool(pool.p), prev(NULL), owned(false) { } - template<typename X> friend std::ostream& operator<<(std::ostream&, const gc_pool_ptr<X>&); - -private: - T* ptr; + apr_pool_t* prev; + bool owned; }; -template<typename T> std::ostream& operator<<(std::ostream& out, const gc_pool_ptr<T>& p) { - return out << p.ptr; -} - /** - * Cleanup function, called by the APR pool to cleanup registered resources. - * Calls the allocated object's destructor. + * Allocates a pointer to an object allocated from a memory pool and + * register a cleanup callback for it. */ -template<typename T> apr_status_t gc_pool_cleanupCallback(void* v) { +template<typename T> apr_status_t gc_pool_cleanup(void* v) { T* t = static_cast<T*>(v); t->~T(); return APR_SUCCESS; } -/** - * Returns a pointer to an object allocated from a memory pool. - */ -template<typename T> gc_pool_ptr<T> gc_pool_new(const gc_pool& mp) { +template<typename T> T* gc_new(apr_pool_t* p) { + void* m = apr_palloc(p, sizeof(T)); + apr_pool_cleanup_register(p, m, gc_pool_cleanup<T>, apr_pool_cleanup_null) ; + return static_cast<T*>(m); +} + +template<typename T> T* gc_new() { + return gc_new<T>(gc_current_pool()); +} + +template<typename T> apr_status_t gc_pool_acleanup(void* v) { + int* m = static_cast<int*>(v); + int n = *m; + T* t = static_cast<T*>(m + 1); + for (int i = 0; i < n; i++, t++) + t->~T(); + return APR_SUCCESS; +} - // Allocate memory from the pool - void* m = apr_palloc(mp, sizeof(T)); +template<typename T> T* gc_anew(apr_pool_t* p, int n) { + int* m = static_cast<int*>(apr_palloc(p, sizeof(int) + sizeof(T[n]))); + *m = n; + apr_pool_cleanup_register(p, m, gc_pool_acleanup<T>, apr_pool_cleanup_null) ; + return static_cast<T*>(m + 1); +} - // Register a cleanup callback - apr_pool_cleanup_register(mp, m, gc_pool_cleanupCallback<T>, apr_pool_cleanup_null) ; +template<typename T> T* gc_anew(int n) { + return gc_anew<T>(gc_current_pool(), n); +} - // Run the requested type's constructor over the allocated memory - return new (m) T(); +/** + * Allocate an array of chars. + */ +char* gc_cnew(apr_pool_t* p, int n) { + return static_cast<char*>(apr_palloc(p, n)); +} + +char* gc_cnew(int n) { + return gc_cnew(gc_current_pool(), n); } } + #endif /* tuscany_gc_hpp */ diff --git a/sca-cpp/trunk/kernel/kernel-test.cpp b/sca-cpp/trunk/kernel/kernel-test.cpp index 8a5e4a704d..c4f76c13c9 100644 --- a/sca-cpp/trunk/kernel/kernel-test.cpp +++ b/sca-cpp/trunk/kernel/kernel-test.cpp @@ -24,12 +24,10 @@ */ #include <assert.h> -#include <iostream> -#include <string> -#include <sstream> +#include "string.hpp" +#include "sstream.hpp" #include "function.hpp" #include "list.hpp" -#include "slist.hpp" #include "tree.hpp" #include "value.hpp" #include "monad.hpp" @@ -77,7 +75,10 @@ bool testLambda() { bool testLambdaGC() { resetLambdaCounters(); - testLambda(); + { + gc_scoped_pool gc; + testLambda(); + } assert(checkLambdaCounters()); return true; } @@ -87,18 +88,15 @@ int countElements = 0; struct Element { int i; - Element() : - i(0) { + Element() : i(0) { countElements++; } - Element(int i) : - i(i) { + Element(int i) : i(i) { countElements++; } - Element(const Element& o) : - i(o.i) { + Element(const Element& o) : i(o.i) { countElements++; } @@ -110,7 +108,7 @@ struct Element { return o.i == i; } }; -std::ostream& operator<<(std::ostream& out, const Element& v) { +ostream& operator<<(ostream& out, const Element& v) { out << v.i ; return out; } @@ -124,23 +122,14 @@ bool testCons() { return true; } -bool testSet() { - list<int> l = mklist(1, 2, 3); - setCar(l, 4); - setCdr(l, mklist(5, 6)); - assert(car(l) == 4); - assert(cadr(l) == 5); - assert(caddr(l) == 6); - assert(isNil(cdddr(l))); - return true; -} - bool testListGC() { resetLambdaCounters(); resetListCounters(); countElements = 0; - testCons(); - testSet(); + { + gc_scoped_pool gc; + testCons(); + } assert(checkLambdaCounters()); assert(checkListCounters()); assert(countElements == 0); @@ -148,13 +137,13 @@ bool testListGC() { } bool testOut() { - std::ostringstream os1; + ostringstream os1; os1 << list<int> (); - assert(os1.str() == "()"); + assert(str(os1) == "()"); - std::ostringstream os2; + ostringstream os2; os2 << mklist(1, 2, 3); - assert(os2.str() == "(1 2 3)"); + assert(str(os2) == "(1 2 3)"); return true; } @@ -180,10 +169,7 @@ bool testAppend() { assert(car(cdr(cdr(append(mklist(1), mklist(2, 3))))) == 3); assert(isNil(cdr(cdr(cdr(append(mklist(1), mklist(2, 3))))))); - list<int> l; - l << 1 << 2 << 3; - assert(l == mklist(1, 2, 3)); - assert(list<int>() << 1 << 2 << 3 == mklist(1, 2, 3)); + assert(list<int>() + 1 + 2 + 3 == mklist(1, 2, 3)); return true; } @@ -196,7 +182,7 @@ struct Complex { x(x), y(y) { } }; -std::ostream& operator<<(std::ostream& out, const Complex& v) { +ostream& operator<<(ostream& out, const Complex& v) { out << "[" << v.x << ":" << v.y << "]"; return out; } @@ -266,9 +252,9 @@ bool testListRef() { } bool testAssoc() { - const list<list<std::string> > l = mklist(mklist<std::string>("x", "X"), mklist<std::string>("a", "A"), mklist<std::string>("y", "Y"), mklist<std::string>("a", "AA")); - assert(assoc<std::string>("a", l) == mklist<std::string>("a", "A")); - assert(isNil(assoc<std::string>("z", l))); + const list<list<string> > l = mklist(mklist<string>("x", "X"), mklist<string>("a", "A"), mklist<string>("y", "Y"), mklist<string>("a", "AA")); + assert(assoc<string>("a", l) == mklist<string>("a", "A")); + assert(isNil(assoc<string>("z", l))); const list<list<value> > u = mklist(mklist<value>("x", "X"), mklist<value>("a", "A"), mklist<value>("y", "Y"), mklist<value>("a", "AA")); assert(assoc<value>("a", u) == mklist<value>("a", "A")); @@ -279,21 +265,21 @@ bool testAssoc() { } bool testZip() { - const list<std::string> k = mklist<std::string>("x", "a", "y", "a"); - const list<std::string> v = mklist<std::string>("X", "A", "Y", "AA"); - const list<list<std::string> > z = mklist(k, v); - const list<list<std::string> > u = mklist(mklist<std::string>("x", "X"), mklist<std::string>("a", "A"), mklist<std::string>("y", "Y"), mklist<std::string>("a", "AA")); + const list<string> k = mklist<string>("x", "a", "y", "a"); + const list<string> v = mklist<string>("X", "A", "Y", "AA"); + const list<list<string> > z = mklist(k, v); + const list<list<string> > u = mklist(mklist<string>("x", "X"), mklist<string>("a", "A"), mklist<string>("y", "Y"), mklist<string>("a", "AA")); assert(zip(k, v) == u); assert(unzip(u) == z); return true; } bool testTokenize() { - assert(tokenize("/", "aaa/bbb/ccc/ddd") == mklist<std::string>("aaa", "bbb", "ccc", "ddd")); - assert(tokenize("/", "/bbb/ccc/ddd") == mklist<std::string>("", "bbb", "ccc", "ddd")); - assert(tokenize("/", "/bbb/ccc/") == mklist<std::string>("", "bbb", "ccc")); - assert(tokenize("/", "/bbb//ccc/") == mklist<std::string>("", "bbb", "", "ccc")); - assert(tokenize("/", "abc/def/") == mklist<std::string>("abc", "def")); + assert(tokenize("/", "aaa/bbb/ccc/ddd") == mklist<string>("aaa", "bbb", "ccc", "ddd")); + assert(tokenize("/", "/bbb/ccc/ddd") == mklist<string>("", "bbb", "ccc", "ddd")); + assert(tokenize("/", "/bbb/ccc/") == mklist<string>("", "bbb", "ccc")); + assert(tokenize("/", "/bbb//ccc/") == mklist<string>("", "bbb", "", "ccc")); + assert(tokenize("/", "abc/def/") == mklist<string>("abc", "def")); return true; } @@ -336,13 +322,11 @@ bool testValue() { const list<value> v = mklist<value>(mklist<value>("x", "X"), mklist<value>("a", "A"), mklist<value>("y", "Y")); assert(cadr((list<list<value> >)value(v)) == mklist<value>("a", "A")); - const value pv(gc_ptr<value>(new value(1))); + const value pv(gc_ptr<value>(new (gc_new<value>()) value(1))); assert(*(gc_ptr<value>)pv == value(1)); - const list<value> lpv = mklist<value>(gc_ptr<value>(new value(1)), gc_ptr<value>(new value(2))); + const list<value> lpv = mklist<value>(gc_ptr<value>(new (gc_new<value>()) value(1)), gc_ptr<value>(new (gc_new<value>()) value(2))); assert(*(gc_ptr<value>)car(lpv) == value(1)); - *(gc_ptr<value>)cadr(lpv) = value(3); - assert(*(gc_ptr<value>)cadr(lpv) == value(3)); return true; } @@ -350,7 +334,10 @@ bool testValueGC() { resetLambdaCounters(); resetListCounters(); resetValueCounters(); - testValue(); + { + gc_scoped_pool gc; + testValue(); + } assert(checkValueCounters()); assert(checkLambdaCounters()); assert(checkListCounters()); @@ -371,8 +358,8 @@ bool testTree() { return true; } -const list<value> lta(const std::string& x) { - return mklist<value>(x.c_str(), (x + x).c_str()); +const list<value> lta(const string& x) { + return mklist<value>(c_str(x), c_str(x + x)); } bool testTreeAssoc() { @@ -425,7 +412,7 @@ struct nestedFibMapPerf { bool testCppPerf() { { const lambda<bool()> fml = fibMapPerf(); - std::cout << "Fibonacci map test " << (time(fml, 1, 1) / 1000) << " ms" << std::endl; + cout << "Fibonacci map test " << (time(fml, 1, 1) / 1000) << " ms" << endl; } { @@ -443,7 +430,7 @@ bool testCppPerf() { }; const lambda<bool()> nfml = nestedFibMapPerf(lambda<double(const double)>(nested::fib)); - std::cout << "Nested Fibonacci map test " << (time(nfml, 1, 1) / 1000) << " ms" << std::endl; + cout << "Nested Fibonacci map test " << (time(nfml, 1, 1) / 1000) << " ms" << endl; } return true; } @@ -490,26 +477,26 @@ bool testMaybeMonad() { return true; } -const failable<int, std::string> failableF(const int v) { +const failable<int> failableF(const int v) { return v * 2; } -const failable<int, std::string> failableG(const int v) { +const failable<int> failableG(const int v) { return v * 3; } -const failable<int, std::string> failableH(const int v) { +const failable<int> failableH(const int v) { return failableF(v) >> failableG; } bool testFailableMonad() { - const failable<int, std::string> m(2); + const failable<int> m(2); assert(m >> failableF == failableF(2)); - assert((m >> success<int, std::string>()) == m); + assert((m >> success<int, string>()) == m); assert(m >> failableF >> failableG == m >> failableH); - std::cout << "Failable monad test... "; - failable<int, std::string> ooops = mkfailure<int, std::string>("test"); + cout << "Failable monad test... " << endl; + failable<int> ooops = mkfailure<int>("test"); assert(reason(ooops) == "test"); assert(ooops >> failableF >> failableG == ooops); return true; @@ -553,14 +540,14 @@ bool testStateMonad() { } bool testDynLib() { - const failable<lib, std::string> dl(dynlib(".libs/libdynlib-test" + dynlibExt)); + const failable<lib> dl(dynlib(string(".libs/libdynlib-test") + dynlibExt)); assert(hasContent(dl)); - const failable<lambda<int(const int)>, std::string> sq(dynlambda<int(const int)>("csquare", content(dl))); + const failable<lambda<int(const int)>> sq(dynlambda<int(const int)>("csquare", content(dl))); assert(hasContent(sq)); lambda<int(const int)> l(content(sq)); assert(l(2) == 4); - const failable<lambda<lambda<int(const int)>()>, std::string> sql(dynlambda<lambda<int(const int)>()>("csquarel", content(dl))); + const failable<lambda<lambda<int(const int)>()>> sql(dynlambda<lambda<int(const int)>()>("csquarel", content(dl))); assert(hasContent(sql)); lambda<lambda<int(const int)>()> ll(content(sql)); assert(ll()(3) == 9); @@ -570,12 +557,11 @@ bool testDynLib() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::testLambda(); tuscany::testLambdaGC(); tuscany::testCons(); - tuscany::testSet(); tuscany::testListGC(); tuscany::testOut(); tuscany::testEquals(); @@ -603,7 +589,7 @@ int main() { tuscany::testStateMonad(); tuscany::testDynLib(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/kernel/list.hpp b/sca-cpp/trunk/kernel/list.hpp index 88163e63d2..653f49dfe5 100644 --- a/sca-cpp/trunk/kernel/list.hpp +++ b/sca-cpp/trunk/kernel/list.hpp @@ -26,9 +26,9 @@ * Simple list functions. */ -#include <string> -#include <sstream> -#include <iostream> +#include <assert.h> +#include "string.hpp" +#include "fstream.hpp" #include "function.hpp" #include "debug.hpp" @@ -56,28 +56,33 @@ bool checkListCounters() { } bool printListCounters() { - std::cout << "countLists " << countLists << std::endl; - std::cout << "countELists " << countELists << std::endl; - std::cout << "countILists " << countILists << std::endl; - std::cout << "countCLists " << countCLists << std::endl; + cout << "countLists " << countLists << endl; + cout << "countELists " << countELists << endl; + cout << "countILists " << countILists << endl; + cout << "countCLists " << countCLists << endl; return true; } -#define debug_watchList() do { \ - this->watch = watchList(*this); \ - } while (0) - #else #define resetListCounters() #define checkListCounters() true #define printListCounters() +#endif + +#ifdef _DEBUG_WATCH + +#define debug_watchList() do { \ + this->watch = watchList(*this); \ + } while (0) + +#else + #define debug_watchList(); #endif - /** * A car/cdr lisp-like pair, base structure to construct lists. */ @@ -91,28 +96,26 @@ public: debug_watchList(); } - list(const T car, const lambda<list<T>()>& cdr) : - car(car), cdr(cdr) { + list(const T car, const lambda<list<T>()>& cdr) : car(car), cdr(cdr) { debug_inc(countLists); debug_inc(countILists); debug_watchList(); } - list(const list& p) : - car(p.car), cdr(p.cdr) { + list(const list& p) : car(p.car), cdr(p.cdr) { debug_inc(countLists); debug_inc(countCLists); -#ifdef _DEBUG +#ifdef _DEBUG_WATCH watch = p.watch; #endif } - const list& operator=(const list<T>& p) { + const list<T>& operator=(const list<T>& p) { if(this == &p) return *this; car = p.car; cdr = p.cdr; -#ifdef _DEBUG +#ifdef _DEBUG_WATCH watch = p.watch; #endif return *this; @@ -172,41 +175,34 @@ public: return (list<list<T> >)T(*this); } - list<T>& operator<<(const T& v) { - *this = append(*this, mklist(v)); - return *this; - } +private: +#ifdef _DEBUG_WATCH + template<typename X> friend const string watchList(const list<X>& p); + string watch; +#endif template<typename X> friend const bool isNil(const list<X>& p); template<typename X> friend const X car(const list<X>& p); template<typename X> friend const list<X> cdr(const list<X>& p); - template<typename X> friend const bool setCar(list<X>& p, const X& car); - template<typename X> friend const bool setCdr(list<X>& p, const list<X>& cdr); - template<typename X> friend const bool setCdr(list<X>& p, const lambda<list<X>()>& cdr); - -private: -#ifdef _DEBUG - template<typename X> friend const std::string watchList(const list<X>& p); - std::string watch; -#endif T car; lambda<list<T>()> cdr; }; -#ifdef _DEBUG +#ifdef _DEBUG_WATCH /** * Debug utility used to write the contents of a list to a string, easier * to watch than the list itself in a debugger. */ -template<typename T> const std::string watchList(const list<T>& p) { +template<typename T> const string watchList(const list<T>& p) { if(isNil(p)) return "()"; - std::ostringstream os; + ostringstream<string::npos> os; os << "(" << car(p) << " ...)"; - return os.str(); + return str(os); } + #endif /** @@ -219,14 +215,14 @@ template<typename T> const bool isNil(const list<T>& p) { /** * Write a list to an output stream. */ -template<typename T> std::ostream& writeHelper(std::ostream& out, const list<T>& l) { +template<typename T> ostream& writeHelper(ostream& out, const list<T>& l) { if (isNil(l)) return out; out << " " << car(l); return writeHelper(out, cdr(l)); } -template<typename T> std::ostream& operator<<(std::ostream& out, const list<T>& l) { +template<typename T> ostream& operator<<(ostream& out, const list<T>& l) { if(isNil(l)) return out << "()"; out << "(" << car(l); @@ -305,6 +301,8 @@ template<typename T> const list<T> mklist(const T& a, const T& b, const T& c, co * Returns the car of a list. */ template<typename T> const T car(const list<T>& p) { + // Abort if trying to access the car of a nil list + assert(!isNil(p.cdr)); return p.car; } @@ -316,31 +314,6 @@ template<typename T> const list<T> cdr(const list<T>& p) { } /** - * Sets the car of a list. - */ -template<typename T> const bool setCar(list<T>& p, const T& car) { - p.car = car; - return true; -} - -/** - * Sets the cdr of a list. - */ -template<typename T> const bool setCdr(list<T>& p, const list<T>& c) { - p.cdr = result(c); - return true; -} - -/** - * Sets the cdr of a list to a lambda function. - */ -template<typename T> const bool setCdr(list<T>& p, const lambda<list<T>()>& cdr) { - p.cdr = cdr; - return true; -} - - -/** * Returns the car of the cdr of a list. */ template<typename T> const T cadr(const list<T>& p) { @@ -419,6 +392,17 @@ template<typename T> const list<T> append(const list<T>&a, const list<T>& b) { } /** + * Append a value to a list. + */ +template<typename T> const list<T> operator+(const list<T>& l, const T& v) { + return append(l, mklist(v)); +} + +template<typename T, typename V> const list<T> operator+(const list<T>& l, const V& v) { + return append(l, mklist<T>(v)); +} + +/** * Map a lambda function on a list. */ template<typename T, typename R> const list<R> map(const lambda<R(const T)>& f, const list<T>& p) { diff --git a/sca-cpp/trunk/kernel/mem-test.cpp b/sca-cpp/trunk/kernel/mem-test.cpp new file mode 100644 index 0000000000..b1164a5a36 --- /dev/null +++ b/sca-cpp/trunk/kernel/mem-test.cpp @@ -0,0 +1,162 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +/* $Rev$ $Date$ */ + +/** + * Test memory allocation functions. + */ + +#include <assert.h> +#include "stream.hpp" +#include "string.hpp" +#include "gc.hpp" +#include "function.hpp" +#include "perf.hpp" + +namespace tuscany { + +int countElements = 0; +int maxElements = 0; + +class Element { +public: + Element() : i(0) { + countElements++; + if (countElements > maxElements) + maxElements = countElements; + } + + Element(int i) : i(i) { + countElements++; + if (countElements > maxElements) + maxElements = countElements; + } + + Element(const Element& o) : i(o.i) { + countElements++; + if (countElements > maxElements) + maxElements = countElements; + } + + ~Element() { + countElements--; + } + + const bool operator==(const Element& o) const { + return o.i == i; + } + +private: + friend ostream& operator<<(ostream& out, const Element& v); + + int i; + char c[20]; +}; + +ostream& operator<<(ostream& out, const Element& v) { + out << v.i ; + return out; +} + +bool poolAlloc(Element** p, const int count) { + if (count == 0) + return true; + p[count - 1] = new (gc_new<Element>()) Element(); + return poolAlloc(p, count - 1); +}; + +bool poolFree(Element** p, const int count) { + if (count == 0) + return true; + // Do nothing to free the element, but cycle through them just + // to get a fair comparison with the other memory alloc tests + return poolFree(p, count - 1); +}; + +struct poolAllocPerf { + const int n; + Element** p; + poolAllocPerf(const int n) : n(n), p(new Element*[n]) { + } + const bool operator()() const { + gc_scoped_pool gc; + poolAlloc(p, n); + return true; + } +}; + +bool testPoolAllocPerf() { + const int count = 100000; + const lambda<bool()> pl = poolAllocPerf(count); + maxElements = 0; + cout << "Memory pool alloc test " << (time(pl, 1, 1) / count) << " ms" << endl; + assert(countElements == 0); + assert(maxElements == count); + return true; +} + +bool stdAlloc(Element** p, const int count) { + if (count == 0) + return true; + p[count - 1] = new Element(); + return stdAlloc(p, count - 1); +}; + +bool stdFree(Element** p, const int count) { + if (count == 0) + return true; + delete p[count -1]; + return stdFree(p, count - 1); +}; + +struct stdAllocPerf { + const int n; + Element** p; + stdAllocPerf(const int n) : n(n), p(new Element*[n]) { + } + const bool operator()() const { + stdAlloc(p, n); + stdFree(p, n); + return true; + } +}; + +bool testStdAllocPerf() { + const int count = 100000; + const lambda<bool()> sl = stdAllocPerf(count); + maxElements = 0; + cout << "Memory standard alloc test " << (time(sl, 1, 1) / count) << " ms" << endl; + assert(countElements == 0); + assert(maxElements == count); + return true; +} + +} + +int main() { + tuscany::cout << "Testing..." << tuscany::endl; + + tuscany::testPoolAllocPerf(); + tuscany::testStdAllocPerf(); + + tuscany::cout << "OK" << tuscany::endl; + + return 0; +} diff --git a/sca-cpp/trunk/kernel/monad.hpp b/sca-cpp/trunk/kernel/monad.hpp index 5449aa38fd..d2057cf367 100644 --- a/sca-cpp/trunk/kernel/monad.hpp +++ b/sca-cpp/trunk/kernel/monad.hpp @@ -26,11 +26,10 @@ * Simple monad implementations. */ -#include <string> -#include <iostream> - #include "function.hpp" #include "debug.hpp" +#include "string.hpp" +#include "stream.hpp" namespace tuscany { @@ -70,7 +69,7 @@ private: /** * Write an identity monad to a stream. */ -template<typename V> std::ostream& operator<<(std::ostream& out, const id<V>& m) { +template<typename V> ostream& operator<<(ostream& out, const id<V>& m) { out << content(m); return out; } @@ -148,7 +147,7 @@ private: /** * Write a maybe monad to a stream. */ -template<typename V> std::ostream& operator<<(std::ostream& out, const maybe<V>& m) { +template<typename V> ostream& operator<<(ostream& out, const maybe<V>& m) { if (!hasContent(m)) { out << "nothing"; return out; @@ -203,7 +202,7 @@ template<typename R, typename V> const maybe<R> operator>>(const maybe<V>& m, co * To get the value in the monad, just cast it to the value type. * To get the failure in the monad, cast it to the failure type. */ -template<typename V, typename F> class failable { +template<typename V, typename F = string> class failable { public: failable() : hasv(false) { } @@ -211,22 +210,7 @@ public: failable(const V& v) : hasv(true), v(v) { } - failable(const failable<V, F>& m) : hasv(m.hasv) { - if (hasv) - v = m.v; - else - f = m.f; - } - - const failable<V, F>& operator=(const failable<V, F>& m) { - if(this == &m) - return *this; - hasv = m.hasv; - if (hasv) - v = m.v; - else - f = m.f; - return *this; + failable(const failable<V, F>& m) : hasv(m.hasv), v(m.v), f(m.f) { } const bool operator!=(const failable<V, F>& m) const { @@ -242,23 +226,28 @@ public: } private: - bool hasv; - V v; - F f; - failable(const bool hasv, const F& f) : hasv(hasv), f(f) { } + // Prevent mutation + const failable<V, F>& operator=(const failable<V, F>& m) { + return *this; + } + template<typename A, typename B> friend const bool hasContent(const failable<A, B>& m); template<typename A, typename B> friend const A content(const failable<A, B>& m); template<typename A, typename B> friend const B reason(const failable<A, B>& m); template<typename A, typename B> friend const failable<A, B> mkfailure(const B& f); + + bool hasv; + V v; + F f; }; /** * Write a failable monad to a stream. */ -template<typename V, typename F> std::ostream& operator<<(std::ostream& out, const failable<V, F>& m) { +template<typename V, typename F> ostream& operator<<(ostream& out, const failable<V, F>& m) { if (!hasContent(m)) { out << reason(m); return out; @@ -286,6 +275,10 @@ template<typename V, typename F> const failable<V, F> mkfailure(const F& f) { return failable<V, F>(false, f); } +template<typename V> const failable<V> mkfailure(const char* f) { + return mkfailure<V, string>(string(f)); +} + template<typename V, typename F> const lambda<failable<V, F>(const V)> failure() { return mkfailure<V, F>; } @@ -421,7 +414,7 @@ private: /** * Write a state monad to a stream. */ -template<typename S, typename V> std::ostream& operator<<(std::ostream& out, const state<S, V>& m) { +template<typename S, typename V> ostream& operator<<(ostream& out, const state<S, V>& m) { const S s = m; const V v = m; out << '(' << s << ' ' << v << ')'; diff --git a/sca-cpp/trunk/kernel/parallel-test.cpp b/sca-cpp/trunk/kernel/parallel-test.cpp index 8ae2eeed2c..b47501a58d 100644 --- a/sca-cpp/trunk/kernel/parallel-test.cpp +++ b/sca-cpp/trunk/kernel/parallel-test.cpp @@ -24,8 +24,8 @@ */ #include <assert.h> -#include <iostream> -#include <string> +#include "stream.hpp" +#include "string.hpp" #include "function.hpp" #include "list.hpp" #include "perf.hpp" @@ -33,6 +33,8 @@ namespace tuscany { +#ifdef _REENTRANT + int inci = 0; struct incPerf { @@ -84,25 +86,25 @@ bool testAtomicPerf() { const int count = 100000; { const lambda<bool()> l = incPerf(); - std::cout << "Non-atomic inc test " << time(l, 1000, count) << " ms" << std::endl; + cout << "Non-atomic inc test " << time(l, 1000, count) << " ms" << endl; assert(inci == count + 1000); } { const lambda<bool()> l = addAndFetchPerf(); - std::cout << "Atomic inc test " << time(l, 1000, count) << " ms" << std::endl; + cout << "Atomic inc test " << time(l, 1000, count) << " ms" << endl; assert(addi == count + 1000); } { pthread_mutex_t mutex; pthread_mutex_init(&mutex, NULL); const lambda<bool()> l = mutexPerf(&mutex); - std::cout << "Locked inc test " << time(l, 1000, count) << " ms" << std::endl; + cout << "Locked inc test " << time(l, 1000, count) << " ms" << endl; assert(muxi == count + 1000); pthread_mutex_destroy(&mutex); } { const lambda<bool()> l = tlsPerf(); - std::cout << "Thread local inc test " << time(l, 1000, count) << " ms" << std::endl; + cout << "Thread local inc test " << time(l, 1000, count) << " ms" << endl; assert(tlsi == count + 1000); } return true; @@ -114,38 +116,51 @@ const int mtsquare(const int x) { return x * x; } +bool checkResults(const list<future<int> > r, int i) { + if (isNil(r)) + return true; + assert(car(r) == i * i); + checkResults(cdr(r), i + 1); + return true; +} + +const list<future<int> > submitSquares(worker& w, const int max, const int i) { + if (i == max) + return list<future<int> >(); + const lambda<int()> func = curry(lambda<int(const int)> (mtsquare), i); + return cons(submit(w, func), submitSquares(w, max, i + 1)); +} + bool testWorker() { - worker w(10); + worker w(20); { const lambda<int()> func = curry(lambda<int(const int)> (mtsquare), 2); assert(submit(w, func) == 4); } { - const int max = 10; - - list<future<int> > r; - for(int i = 0; i < max; i++) { - const lambda<int()> func = curry(lambda<int(const int)> (mtsquare), i); - r = cons(submit(w, func), r); - } - for(int i = max - 1; i >= 0; i--) { - assert(car(r) == i * i); - r = cdr(r); - } + const int max = 20; + const list<future<int> > r(submitSquares(w, max, 0)); + checkResults(r, 0); } shutdown(w); return true; } +#endif + } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; +#ifdef _REENTRANT tuscany::testAtomicPerf(); tuscany::testWorker(); +#else + tuscany::cout << "Skipped multi-thread tests" << tuscany::endl; +#endif - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/kernel/parallel.hpp b/sca-cpp/trunk/kernel/parallel.hpp index a94764763a..33cb735b84 100644 --- a/sca-cpp/trunk/kernel/parallel.hpp +++ b/sca-cpp/trunk/kernel/parallel.hpp @@ -26,13 +26,18 @@ * Simple parallel work execution functions. */ +#ifdef _REENTRANT #include <pthread.h> #include <sys/syscall.h> +#include <unistd.h> +#endif #include "function.hpp" namespace tuscany { +#ifdef _REENTRANT + /** * Returns the current thread id. */ @@ -48,8 +53,7 @@ template<typename T> class future { private: template<typename X> class futureValue { public: - futureValue() : - refCount(0), hasValue(false) { + futureValue() : hasValue(false) { pthread_mutex_init(&valueMutex, NULL); pthread_cond_init(&valueCond, NULL); } @@ -59,14 +63,6 @@ private: pthread_cond_destroy(&valueCond); } - unsigned int acquire() { - return __sync_add_and_fetch(&refCount, (unsigned int)1); - } - - unsigned int release() { - return __sync_sub_and_fetch(&refCount, (unsigned int)1); - } - bool set(const T& v) { pthread_mutex_lock(&valueMutex); if(hasValue) { @@ -91,33 +87,28 @@ private: } private: - unsigned refCount; pthread_mutex_t valueMutex; pthread_cond_t valueCond; bool hasValue; X value; }; - gc_counting_ptr<futureValue<T> > fvalue; + gc_ptr<futureValue<T> > fvalue; template<typename X> friend const X get(const future<X>& f); template<typename X> friend bool set(const future<X>& f, const X& v); public: - future() : fvalue(new futureValue<T>()) { - //std::cout << "future() threadId " << threadId() << "\n"; + future() : fvalue(new (gc_new<futureValue<T> >()) futureValue<T>()) { } ~future() { - //std::cout << "~future() threadId " << threadId() << "\n"; } future(const future& f) : fvalue(f.fvalue) { - //std::cout << "future(const future& f) threadId " << threadId() << "\n"; } const future& operator=(const future& f) { - //std::cout << "future::operator=(const future& f) threadId " << threadId() << "\n"; if (&f == this) return *this; fvalue = f.fvalue; @@ -132,7 +123,6 @@ public: operator const T() const { return fvalue->get(); } - }; /** @@ -140,7 +130,7 @@ public: */ template<typename T> class queue { public: - queue(int max) : max(max), size(0), tail(0), head(0), values(new T[max]) { + queue(int max) : max(max), size(0), tail(0), head(0), values(new (gc_anew<T>(max)) T[max]) { pthread_mutex_init(&mutex, NULL); pthread_cond_init(&full, NULL); pthread_cond_init(&empty, NULL); @@ -160,7 +150,7 @@ private: pthread_mutex_t mutex; pthread_cond_t full; pthread_cond_t empty; - gc_aptr<T> values; + gc_ptr<T> values; template<typename X> friend const int enqueue(queue<X>& q, const X& v); template<typename X> friend const X dequeue(queue<X>& q); @@ -280,5 +270,7 @@ const bool shutdown(worker& w) { return true; } +#endif + } #endif /* tuscany_parallel_hpp */ diff --git a/sca-cpp/trunk/kernel/slist.hpp b/sca-cpp/trunk/kernel/slist.hpp deleted file mode 100644 index 705152cb29..0000000000 --- a/sca-cpp/trunk/kernel/slist.hpp +++ /dev/null @@ -1,96 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ - -/* $Rev$ $Date$ */ - -#ifndef tuscany_slist_hpp -#define tuscany_slist_hpp - -/** - * Useful functions to work with lists of strings and character streams. - */ - -#include <iostream> -#include <string> -#include "function.hpp" -#include "list.hpp" - -namespace tuscany { - -/** - * Tokenize a string into a list of strings. - */ -const list<std::string> tokenize(const std::string& sep, const std::string& str) { - struct nested { - static const list<std::string> tokenize(const std::string& sep, const std::string& str, const unsigned int start = 0) { - if (start >= str.length()) - return list<std::string>(); - const unsigned int i = str.find_first_of(sep, start); - if (i == std::string::npos) - return mklist(str.substr(start)); - return cons(str.substr(start, i - start), tokenize(sep, str, i + 1)); - } - }; - return nested::tokenize(sep, str, 0); -} - -/** - * Returns a lazy list view of an input stream. - */ -struct ilistRead{ - std::istream &is; - ilistRead(std::istream& is) : is(is) { - } - const list<std::string> operator()() { - char buffer[1024]; - is.read(buffer, 1024); - const int n = is.gcount(); - if (n ==0) - return list<std::string>(); - return cons(std::string(buffer, n), (*this)()); - } -}; - -const list<std::string> streamList(std::istream& is) { - return ilistRead(is)(); -} - -/** - * Fragment the first element of a list of strings to fit the given max length. - */ -const list<std::string> fragment(list<std::string> l, unsigned int max) { - const std::string s = car(l); - if (s.length() <= max) - return l; - return cons(s.substr(0, max), cons(s.substr(max), cdr(l))); -} - -/** - * Write a list of strings to an output stream. - */ -std::ostream& write(const list<std::string>& l, std::ostream& os) { - if(isNil(l)) - return os; - os << car(l); - return write(cdr(l), os); -} - -} - -#endif /* tuscany_slist_hpp */ diff --git a/sca-cpp/trunk/kernel/sstream.hpp b/sca-cpp/trunk/kernel/sstream.hpp new file mode 100644 index 0000000000..5fcdb0c22b --- /dev/null +++ b/sca-cpp/trunk/kernel/sstream.hpp @@ -0,0 +1,234 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +/* $Rev$ $Date$ */ + +#ifndef tuscany_sstream_hpp +#define tuscany_sstream_hpp + +/** + * Char buffer based streams. + */ + +#include <stdio.h> +#include <stdarg.h> +#include <memory.h> +#include "string.hpp" +#include "stream.hpp" +#include "list.hpp" + +namespace tuscany { + +/** + * Instrumentable memcpy. + */ +void* stream_memcpy(void* t, const void* s, const size_t n) { + return memcpy(t, s, n); +} + +/** + * Output stream backed by a char buffer. + */ +class ostringstream : public ostream { +public: + ostringstream() : len(0) { + } + + ~ostringstream() { + } + + ostringstream(const ostringstream& os) { + len = os.len; + buf = os.buf; + } + + ostringstream& vprintf(const char* fmt, ...) { + va_list args; + va_start (args, fmt); + string s; + s.len = vsnprintf(NULL, 0, fmt, args); + s.buf = gc_cnew(s.len + 1); + vsnprintf(s.buf, s.len + 1, fmt, args); + buf = cons(s, buf); + len += s.len; + va_end (args); + return *this; + } + + ostringstream& flush() { + return *this; + } + +private: + static const bool strHelper(const list<string> l, char* buf) { + if (isNil(l)) + return true; + const string c = car(l); + char* b = buf - length(c); + memcpy(b, c_str(c), length(c)); + return strHelper(cdr(l), b); + } + + const string str() { + if (isNil(buf)) + return string(); + string s; + s.len = len; + s.buf = gc_cnew(s.len + 1); + strHelper(buf, s.buf + len); + s.buf[s.len] = '\0'; + return s; + } + + friend const string str(ostringstream& os); + + int len; + list<string> buf; +}; + +/** + * Return a string representation of a stream. + */ +const string str(ostringstream& os) { + return os.str(); +} + +/** + * Input stream backed by a char buffer + */ +class istringstream : public istream { +public: + istringstream(const string& s) { + cur = 0; + const int slen = length(s); + len = slen; + buf = c_str(s); + } + + ~istringstream() { + } + + istringstream(const istringstream& is) { + len = is.len; + cur = is.cur; + buf = is.buf; + } + + const int read(void* b, int size) { + const int n = len - cur; + if (n == 0) + return 0; + if (n > size) { + stream_memcpy(b, buf + cur, size); + cur = cur + size; + return size; + } + stream_memcpy(b, buf + cur, n); + cur = cur + n; + return n; + } + + const bool eof() { + return cur == len; + } + + const bool fail() { + return false; + } + + const int get() { + if (eof()) + return -1; + const int c = buf[cur]; + cur += 1; + return c; + } + + const int peek() { + if (eof()) + return -1; + return buf[cur]; + } + +private: + int len; + int cur; + const char* buf; +}; + +/** + * Tokenize a string into a list of strings. + */ +const list<string> tokenize(const char* sep, const string& str) { + struct nested { + static const list<string> tokenize(const char* sep, const string& str, const int start = 0) { + if (start >= length(str)) + return list<string>(); + const int i = find(str, sep, start); + if (i == length(str)) + return mklist(string(substr(str, start))); + return cons(string(substr(str, start, i - start)), tokenize(sep, str, i + 1)); + } + }; + return nested::tokenize(sep, str, 0); +} + +/** + * Returns a lazy list view of an input stream. + */ +struct ilistRead{ + istream &is; + ilistRead(istream& is) : is(is) { + } + const list<string> operator()() { + char buffer[1024]; + const int n = read(is, buffer, sizeof(buffer)); + if (n ==0) + return list<string>(); + return cons(string(buffer, n), (*this)()); + } +}; + +const list<string> streamList(istream& is) { + return ilistRead(is)(); +} + +/** + * Fragment the first element of a list of strings to fit the given max length. + */ +const list<string> fragment(list<string> l, int max) { + const string s = car(l); + if (length(s) <= max) + return l; + return cons(substr(s, 0, max), cons(substr(s, max), cdr(l))); +} + +/** + * Write a list of strings to an output stream. + */ +ostream& write(const list<string>& l, ostream& os) { + if(isNil(l)) + return os; + os << car(l); + return write(cdr(l), os); +} + +} + +#endif /* tuscany_sstream_hpp */ diff --git a/sca-cpp/trunk/kernel/stream.hpp b/sca-cpp/trunk/kernel/stream.hpp new file mode 100644 index 0000000000..a3e532c4ce --- /dev/null +++ b/sca-cpp/trunk/kernel/stream.hpp @@ -0,0 +1,148 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +/* $Rev$ $Date$ */ + +#ifndef tuscany_stream_hpp +#define tuscany_stream_hpp + +/** + * Basic stream type and functions. + */ + +#include <stdarg.h> +#include "debug.hpp" +#include "gc.hpp" +#include "string.hpp" + +namespace tuscany { + +/** + * Base output stream. + */ +class ostream { +public: + virtual ostream& vprintf(const char* fmt, ...) = 0; + virtual ostream& flush() = 0; +}; + +/** + * Flush a stream. + */ +ostream& flush(ostream& os) { + return os.flush(); +} + +/** + * Write simple values to a stream. + */ +ostream& operator<<(ostream& os, const char* v) { + return os.vprintf("%s", v); +} + +ostream& operator<<(ostream& os, const unsigned char* v) { + return os.vprintf("%s", v); +} + +ostream& operator<<(ostream& os, const char v) { + return os.vprintf("%c", v); +} + +ostream& operator<<(ostream& os, const int v) { + return os.vprintf("%d", v); +} + +ostream& operator<<(ostream& os, const long int v) { + return os.vprintf("%ld", v); +} + +ostream& operator<<(ostream& os, const double v) { + return os.vprintf("%g", v); +} + +ostream& operator<<(ostream& os, const void* v) { + return os.vprintf("%p", v); +} + +ostream& operator<<(ostream& os, const string& v) { + return os.vprintf("%s", c_str(v)); +} + +class stream_endl { +} endl; + +ostream& operator<<(ostream& os, unused const stream_endl e) { + os.vprintf("%s", "\n"); + return os.flush(); +} + +/* + * Input stream. + */ +class istream { +public: + virtual const int read(void* buf, int size) = 0; + virtual const bool eof() = 0; + virtual const bool fail() = 0; + virtual const int get() = 0; + virtual const int peek() = 0; +}; + +/** + * Read from an input stream. + */ +const int read(istream& is, void * buf, int size) { + return is.read(buf, size); +} + +/** + * Return true if the end of an input stream has been reached. + */ +const bool eof(istream& is) { + return is.eof(); +} + +/** + * Return true if an input stream can't be accessed. + */ +const bool fail(istream& is) { + return is.fail(); +} + +/** + * Read a character from a stream. + */ +const int get(istream& is) { + return is.get(); +} + +/** + * Peek a character from a stream. + */ +const int peek(istream& is) { + return is.peek(); +} + +template<typename T> ostream& operator<<(ostream& out, const gc_ptr<T>& p) { + return out << p.ptr; +} + +} + +#endif /* tuscany_stream_hpp */ diff --git a/sca-cpp/trunk/kernel/string-test.cpp b/sca-cpp/trunk/kernel/string-test.cpp new file mode 100644 index 0000000000..323756c7e4 --- /dev/null +++ b/sca-cpp/trunk/kernel/string-test.cpp @@ -0,0 +1,196 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +/* $Rev$ $Date$ */ + +/** + * Test string functions. + */ + +#include <assert.h> +#include <string> +#include "sstream.hpp" +#include "string.hpp" +#include "list.hpp" +#include "perf.hpp" + +namespace tuscany { + +bool testCopies() { + resetStringCopyCounters(); + string x("abcd"); + assert(checkStringCopyCounters(1)); + resetStringCopyCounters(); + string y = string("abcd"); + assert(checkStringCopyCounters(1)); + resetStringCopyCounters(); + string z = y; + assert(checkStringCopyCounters(0)); + resetStringCopyCounters(); + const list<string> pl = list<string>() + "abcd" + "efgh"; + printStringCopyCounters(); + resetStringCopyCounters(); + const list<string> cl = cons<string>("efgh", mklist<string>("abcd")); + printStringCopyCounters(); + return true; +} + +bool testString() { + const string s("abcd"); + assert(length(s) == 4); + assert(!strcmp(c_str(s), "abcd")); + + assert(s == "abcd"); + assert(s == string("abcd")); + assert(s != "zbcd"); + + assert(s < "zbcd"); + assert(s < "zbc"); + assert(s < "abzd"); + assert(s < "abcdz"); + + assert(s > "Abcd"); + assert(s > "Abc"); + assert(s > "abCd"); + assert(s > "Abcdz"); + + const string x = "abcd"; + assert(!strcmp(c_str(x), "abcd")); + + const string y = string("abcd"); + assert(!strcmp(c_str(y), "abcd")); + + assert(string("ab") + "cd" == "abcd"); + + assert(find("abcd", "cd") == 2); + assert(find("abcd", "xy") == length("abcd")); + assert(substr("abcdef", 4) == "ef"); + assert(substr("abcdef", 4, 2) == "ef"); + assert(substr("abcdef", 4, 3) == "ef"); + assert(substr("abcdef", 6, 3) == ""); + return true; +} + +bool testStream() { + ostringstream os; + os << "ab" << "cd"; + cout << str(os) << endl; + assert(str(os) == "abcd"); + + ostringstream cs; + cs << "\'"; + assert(str(cs) == "\'"); + cs << '\''; + assert(str(cs) == "\'\'"); + + istringstream is("abcd"); + char b[2]; + assert(read(is, b, 2) == 2); + assert(string("ab") == string(b, 2)); + assert(eof(is) == false); + assert(read(is, b, 2) == 2); + assert(string("cd") == string(b, 2)); + assert(eof(is) == true); + assert(read(is, b, 2) == 0); + return true; +} + +std::string stdAdd(std::string& x, std::string& y) { + return x + y; +} + +string add(string& x, string& y) { + return x + y; +} + +char charBuffer[16384]; + +struct addStrings{ + const int size; + addStrings(const int size) : size(size) { + } + bool operator()() const { + const int sz = size / 4; + string x(charBuffer, sz); + string y(charBuffer, sz); + assert(length(add(x, y)) == sz * 2); + return true; + } +}; + +struct addStdStrings{ + const int size; + addStdStrings(const int size) : size(size) { + } + bool operator()() const { + const int sz = size / 4; + std::string x(charBuffer, sz); + std::string y(charBuffer, sz); + assert(stdAdd(x, y).length() == (unsigned int)(sz * 2)); + return true; + } +}; + +bool testStringPerf() { + memset(charBuffer, 'A', 16384); + charBuffer[16384] = '\0'; + + const int count = 100000; + { + const lambda<bool()> a16 = addStrings(16); + cout << "string test " << time(a16, 5, count) << " ms" << endl; + const lambda<bool()> a32 =addStrings(32); + cout << "string test " << time(a32, 5, count) << " ms" << endl; + const lambda<bool()> a256 =addStrings(256); + cout << "string test " << time(a256, 5, count) << " ms" << endl; + const lambda<bool()> a1024 =addStrings(1024); + cout << "string test " << time(a1024, 5, count) << " ms" << endl; + const lambda<bool()> a4096 =addStrings(4096); + cout << "string test " << time(a4096, 5, count) << " ms" << endl; + } + { + const lambda<bool()> a16 =addStdStrings(16); + cout << "Std string test " << time(a16, 5, count) << " ms" << endl; + const lambda<bool()> a32 =addStdStrings(32); + cout << "Std string test " << time(a32, 5, count) << " ms" << endl; + const lambda<bool()> a256 =addStdStrings(256); + cout << "Std string test " << time(a256, 5, count) << " ms" << endl; + const lambda<bool()> a1024 =addStdStrings(1024); + cout << "Std string test " << time(a1024, 5, count) << " ms" << endl; + const lambda<bool()> a4096 =addStdStrings(4096); + cout << "Std string test " << time(a4096, 5, count) << " ms" << endl; + } + + return true; +} + +} + +int main() { + tuscany::cout << "Testing..." << tuscany::endl; + + tuscany::testCopies(); + tuscany::testString(); + tuscany::testStream(); + tuscany::testStringPerf(); + + tuscany::cout << "OK" << tuscany::endl; + + return 0; +} diff --git a/sca-cpp/trunk/kernel/string.hpp b/sca-cpp/trunk/kernel/string.hpp new file mode 100644 index 0000000000..f065bcc9a4 --- /dev/null +++ b/sca-cpp/trunk/kernel/string.hpp @@ -0,0 +1,288 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +/* $Rev$ $Date$ */ + +#ifndef tuscany_string_hpp +#define tuscany_string_hpp + +/** + * Simple and fast string type backed by a char buffer + */ + +#include <assert.h> +#include <string.h> +#include <memory.h> +#include <stdio.h> +#include "gc.hpp" + +namespace tuscany { + +#ifdef _DEBUG + +/** + * Debug utilities. Counters used to track string copies. + */ +long countStringCopies = 0; + +bool resetStringCopyCounters() { + countStringCopies = 0; + return true; +} + +bool checkStringCopyCounters(long c) { + return countStringCopies == c; +} + +bool printStringCopyCounters() { + printf("countStringCopies %ld\n", countStringCopies); + return true; +} + +#else + +#define resetStringCopyCounters() +#define checkStringCopyCounters(c) true +#define printStringCopyCounters() + +#endif + +/** + * Instrumented memcpy. + */ +void* string_memcpy(void* t, const void* s, const size_t n) { +#ifdef _DEBUG + countStringCopies += 1; +#endif + return memcpy(t, s, n); +} + +char stringEmptyBuffer[1] = { '\0' }; + +/** + * String class. The maximum string size is specified as a template parameter. + */ +class string { +public: + string() : len(0) { + buf = stringEmptyBuffer; + } + + string(const char* s) { + len = strlen(s); + if (len == 0) { + buf = stringEmptyBuffer; + return; + } + buf = gc_cnew(len + 1); + string_memcpy(buf, s, len + 1); + } + + string(const char* s, const int n) { + len = n; + if (len == 0) { + buf = stringEmptyBuffer; + return; + } + buf = gc_cnew(len + 1); + string_memcpy(buf, s, len); + buf[len] = '\0'; + } + + string(const int n, const char c) { + len = n; + if (len == 0) { + buf = stringEmptyBuffer; + return; + } + buf = gc_cnew(len + 1); + memset(buf, c, n); + buf[len] = '\0'; + } + + string(const string& s) { + len = s.len; + buf = s.buf; + } + + const string& operator=(const string& s) { + if (&s == this) + return *this; + len = s.len; + buf = s.buf; + return *this; + } + + const bool operator==(const string& s) const { + if (len != s.len) + return false; + if (buf == s.buf) + return true; + return memcmp(buf, s.buf, len) == 0; + } + + const bool operator!=(const string& s) const { + return !(*this == s); + } + + const bool operator==(const char* s) const { + if (buf == s) + return true; + return strcmp(buf, s) == 0; + } + + const bool operator!=(const char* s) const { + return !(*this == s); + } + + const bool operator<(const string& s) const { + const int n = len < s.len? len : s.len; + const int c = memcmp(buf, s.buf, n); + if (c < 0) + return true; + if (c == 0) + return len < s.len; + return false; + } + + const bool operator>(const string& s) const { + const int n = len < s.len? len : s.len; + int c = memcmp(buf, s.buf, n); + if (c > 0) + return true; + if (c == 0) + return len > s.len; + return false; + } + +private: + friend class ostringstream; + friend const string operator+(const string& a, const string& b); + friend const string operator+(const string& a, const char* b); + friend const int length(const string& s); + friend const char* c_str(const string& s); + friend const int find(const string& s1, const char* s2, const int start); + friend const string substr(const string& s, const int pos, const int n); + + int len; + char* buf; +}; + +/** + * Adds two strings. + */ +const string operator+(const string& a, const string& b) { + string s; + s.len = a.len + b.len; + s.buf = gc_cnew(s.len + 1); + string_memcpy(s.buf, a.buf, a.len); + string_memcpy(s.buf + a.len, b.buf, b.len); + s.buf[s.len] = '\0'; + return s; +} + +const string operator+(const string& a, const char* b) { + string s; + const int blen = strlen(b); + s.len = a.len + blen; + s.buf = gc_cnew(s.len + 1); + string_memcpy(s.buf, a.buf, a.len); + string_memcpy(s.buf + a.len, b, blen); + s.buf[s.len] = '\0'; + return s; +} + +/** + * Returns the length of a string. + */ +const int length(const string& s) { + return s.len; +} + +/** + * Returns a string as a C zero terminated string. + */ +const char* c_str(const string& s) { + return s.buf; +} + +/** + * Find the first occurrence of string s2 in s1, starting at the given position. + */ +const int find(const string& s1, const char* s2, const int start) { + if (start >= s1.len) + return s1.len; + const char *f = strstr(s1.buf + start, s2); + if (f == NULL) + return s1.len; + return f - s1.buf; +} + +const int find(const string& s1, const char* s2) { + return find(s1, s2, 0); +} + +const bool contains(const string& s1, const char* s2) { + return find(s1, s2) != length(s1); +} + +/** + * Find the first occurence of any character from a string in a string. + */ +const int find_first_of(const string& s1, const string& s2) { + return strcspn(c_str(s1), c_str(s2)); +} + +/** + * Find the last occurence of a character in a string. + */ +const int find_last(const string& s, const char c) { + const char* cs = c_str(s); + const char* f = strrchr(cs, c); + if (f == NULL) + return length(s); + return f - cs; +} + +/** + * Return a substring of a string. + */ +const string substr(const string& s, const int pos, const int n) { + if (pos >= s.len) + return string(); + if (pos + n > s.len) + return string(s.buf + pos, s.len - pos); + return string(s.buf + pos, n); +} + +const string substr(const string& s, const int pos) { + return substr(s, pos, length(s)); +} + +/** + * Common string constants. + */ + +string trueString("true"); +string falseString("false"); +string emptyString(""); + +} + +#endif /* tuscany_string_hpp */ diff --git a/sca-cpp/trunk/kernel/tree.hpp b/sca-cpp/trunk/kernel/tree.hpp index f0c85ff403..436385aa1b 100644 --- a/sca-cpp/trunk/kernel/tree.hpp +++ b/sca-cpp/trunk/kernel/tree.hpp @@ -26,8 +26,8 @@ * Functions to work with trees. */ -#include <iostream> -#include <string> +#include "stream.hpp" +#include "string.hpp" #include "function.hpp" #include "list.hpp" #include "monad.hpp" diff --git a/sca-cpp/trunk/kernel/value.hpp b/sca-cpp/trunk/kernel/value.hpp index e767ead74b..d2c5f12e95 100644 --- a/sca-cpp/trunk/kernel/value.hpp +++ b/sca-cpp/trunk/kernel/value.hpp @@ -26,9 +26,9 @@ * Generic value type. */ -#include <string> -#include <iostream> -#include <sstream> +#include <stdlib.h> +#include "string.hpp" +#include "sstream.hpp" #include "gc.hpp" #include "function.hpp" #include "list.hpp" @@ -60,23 +60,29 @@ bool checkValueCounters() { } bool printValueCounters() { - std::cout << "countValues " << countValues << std::endl; - std::cout << "countEValues " << countEValues << std::endl; - std::cout << "countCValues " << countCValues << std::endl; - std::cout << "countVValues " << countVValues << std::endl; + cout << "countValues " << countValues << endl; + cout << "countEValues " << countEValues << endl; + cout << "countCValues " << countCValues << endl; + cout << "countVValues " << countVValues << endl; return true; } -#define debug_watchValue() do { \ - this->watch = watchValue(*this); \ - } while (0) - #else #define resetValueCounters() #define checkValueCounters() true #define printValueCounters() +#endif + +#ifdef _DEBUG_WATCH + +#define debug_watchValue() do { \ + this->watch = watchValue(*this); \ + } while (0) + +#else + #define debug_watchValue() #endif @@ -90,8 +96,7 @@ public: Undefined, Symbol, String, List, Number, Bool, Char, Lambda, Ptr, PoolPtr }; - value() : - type(value::Undefined) { + value() : type(value::Undefined) { debug_inc(countValues); debug_inc(countEValues); debug_watchValue(); @@ -123,43 +128,11 @@ public: default: break; } -#ifdef _DEBUG +#ifdef _DEBUG_WATCH watch = v.watch; #endif } - const value& operator=(const value& v) { - if(this == &v) - return *this; - type = v.type; - switch(type) { - case value::List: - lst() = v.lst(); - case value::Lambda: - func() = v.func(); - case value::Symbol: - str() = v.str(); - case value::String: - str() = v.str(); - case value::Number: - num() = v.num(); - case value::Bool: - boo() = v.boo(); - case value::Char: - chr() = v.chr(); - case value::Ptr: - ptr() = v.ptr(); - case value::PoolPtr: - poolptr() = v.poolptr(); - default: - break; - } -#ifdef _DEBUG - watch = v.watch; -#endif - return *this; - } - virtual ~value() { debug_dec(countValues); } @@ -170,13 +143,13 @@ public: debug_watchValue(); } - value(const std::string& str) : type(value::String), data(vdata(result(str))) { + value(const string& str) : type(value::String), data(vdata(result(str))) { debug_inc(countValues); debug_inc(countVValues); debug_watchValue(); } - value(const char* str) : type(value::Symbol), data(vdata(result(std::string(str)))) { + value(const char* str) : type(value::Symbol), data(vdata(result(string(str)))) { debug_inc(countValues); debug_inc(countVValues); debug_watchValue(); @@ -218,19 +191,21 @@ public: debug_watchValue(); } +#ifdef _GC_REFCOUNT value(const gc_ptr<value> ptr) : type(value::Ptr), data(vdata(result(ptr))) { debug_inc(countValues); debug_inc(countVValues); debug_watchValue(); } +#endif - value(const gc_pool_ptr<value> ptr) : type(value::PoolPtr), data(vdata(result(ptr))) { + value(const gc_ptr<value> ptr) : type(value::PoolPtr), data(vdata(result(ptr))) { debug_inc(countValues); debug_inc(countVValues); debug_watchValue(); } - value(const failable<value, std::string>& m) : type(value::List), + value(const failable<value>& m) : type(value::List), data(vdata(result(hasContent(m)? mklist<value>(content(m)) : mklist<value>(value(), reason(m))))) { debug_inc(countValues); debug_inc(countVValues); @@ -244,6 +219,38 @@ public: debug_watchValue(); } + const value& operator=(const value& v) { + if(this == &v) + return *this; + type = v.type; + switch(type) { + case value::List: + lst() = v.lst(); + case value::Lambda: + func() = v.func(); + case value::Symbol: + str() = v.str(); + case value::String: + str() = v.str(); + case value::Number: + num() = v.num(); + case value::Bool: + boo() = v.boo(); + case value::Char: + chr() = v.chr(); + case value::Ptr: + ptr() = v.ptr(); + case value::PoolPtr: + poolptr() = v.poolptr(); + default: + break; + } +#ifdef _DEBUG_WATCH + watch = v.watch; +#endif + return *this; + } + const bool operator!=(const value& v) const { return !this->operator==(v); } @@ -259,9 +266,8 @@ public: case value::Lambda: return v.type == value::Lambda && func() == v.func(); case value::Symbol: - return str()() == (std::string)v; case value::String: - return str()() == (std::string)v; + return str()() == (string)v; case value::Number: return num()() == (double)v; case value::Bool: @@ -285,8 +291,7 @@ public: return v.type == value::List && lst()() < v.lst()(); case value::Symbol: case value::String: - return str()() < (std::string)v; - return str()() < (std::string)v; + return str()() < (string)v; case value::Bool: return boo()() < (bool)v; case value::Number: @@ -306,8 +311,7 @@ public: return v.type == value::List && lst()() > v.lst()(); case value::Symbol: case value::String: - return str()() > (std::string)v; - return str()() > (std::string)v; + return str()() > (string)v; case value::Bool: return boo()() > (bool)v; case value::Number: @@ -323,25 +327,25 @@ public: return func()(args); } - operator const std::string() const { + operator const string() const { switch(type) { case value::Symbol: case value::String: return str()(); case value::Number: { - std::ostringstream sos; - sos << num()(); - return sos.str(); + ostringstream os; + os << num()(); + return tuscany::str(os); } case value::Bool: - return boo()()? "true" : "false"; + return boo()()? trueString : falseString; case value::Char: { - std::ostringstream sos; - sos << chr()(); - return sos.str(); + ostringstream os; + os << chr()(); + return tuscany::str(os); } default: - return ""; + return emptyString; } } @@ -349,7 +353,7 @@ public: switch(type) { case value::Symbol: case value::String: - return atof(str()().c_str()); + return atof(c_str(str()())); case value::Number: return (double)num()(); case value::Bool: @@ -365,7 +369,7 @@ public: switch(type) { case value::Symbol: case value::String: - return atoi(str()().c_str()); + return atoi(c_str(str()())); case value::Number: return (int)num()(); case value::Bool: @@ -381,7 +385,7 @@ public: switch(type) { case value::Symbol: case value::String: - return str()() == "true"; + return str()() == string("true"); case value::Number: return (int)num()() != 0; case value::Bool: @@ -409,11 +413,13 @@ public: } } +#ifdef _GC_REFCOUNT operator const gc_ptr<value>() const { return ptr()(); } +#endif - operator const gc_pool_ptr<value>() const { + operator const gc_ptr<value>() const { return poolptr()(); } @@ -454,12 +460,12 @@ private: return vdata<gc_ptr<value>()> (); } - lambda<gc_pool_ptr<value>()>& poolptr() const { - return vdata<gc_pool_ptr<value>()> (); + lambda<gc_ptr<value>()>& poolptr() const { + return vdata<gc_ptr<value>()> (); } - lambda<std::string()>& str() const { - return vdata<std::string()> (); + lambda<string()>& str() const { + return vdata<string()> (); } lambda<list<value>()>& lst() const { @@ -482,37 +488,38 @@ private: return cons<list<value> >(list<value>(car(l)), listOfListOfValues(cdr(l))); } - friend std::ostream& operator<<(std::ostream&, const value&); + friend ostream& operator<<(ostream&, const value&); friend const value::ValueType type(const value& v); -#ifdef _DEBUG - friend const std::string watchValue(const value& v); - std::string watch; +#ifdef _DEBUG_WATCH + friend const string watchValue(const value& v); + string watch; #endif ValueType type; lambda<char()> data; }; -#ifdef _DEBUG +#ifdef _DEBUG_WATCH /** * Debug utility used to write the contents of a value to a string, easier * to watch than the value itself in a debugger. */ -const std::string watchValue(const value& v) { +const string watchValue(const value& v) { if (v.type == value::List) return watchList<value>(v); - std::ostringstream os; + ostringstream<string::npos> os; os << v; - return os.str(); + return str(os); } + #endif /** * Write a value to a stream. */ -std::ostream& operator<<(std::ostream& out, const value& v) { +ostream& operator<<(ostream& out, const value& v) { switch(v.type) { case value::List: return out << v.lst()(); @@ -538,8 +545,8 @@ std::ostream& operator<<(std::ostream& out, const value& v) { return out << "gc_ptr::" << p; } case value::PoolPtr: { - const gc_pool_ptr<value> p = v.poolptr()(); - if (p == gc_pool_ptr<value>(NULL)) + const gc_ptr<value> p = v.poolptr()(); + if (p == gc_ptr<value>(NULL)) return out << "pool_ptr::null"; return out << "pool_ptr::" << p; } @@ -634,5 +641,14 @@ const bool isTaggedList(const value& exp, value tag) { return false; } +/** + * Make a list of values from a list of other things. + */ +template<typename T> const list<value> mkvalues(const list<T>& l) { + if (isNil(l)) + return list<value>(); + return cons<value>(car(l), mkvalues(cdr(l))); +} + } #endif /* tuscany_value_hpp */ diff --git a/sca-cpp/trunk/kernel/xml-test.cpp b/sca-cpp/trunk/kernel/xml-test.cpp index 88c476ffef..585a2e519d 100644 --- a/sca-cpp/trunk/kernel/xml-test.cpp +++ b/sca-cpp/trunk/kernel/xml-test.cpp @@ -24,9 +24,8 @@ */ #include <assert.h> -#include <iostream> -#include <string> -#include <sstream> +#include "stream.hpp" +#include "string.hpp" #include "list.hpp" #include "value.hpp" #include "element.hpp" @@ -34,7 +33,7 @@ namespace tuscany { -const std::string currencyXML = +const string currencyXML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<composite xmlns=\"http://docs.oasis-open.org/ns/opencsa/sca/200903\" " "xmlns:t=\"http://tuscany.apache.org/xmlns/sca/1.1\" " @@ -56,7 +55,7 @@ const std::string currencyXML = "</composite>" "\n"; -const std::string customerXML = +const string customerXML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<customer>" "<name>jdoe</name>" @@ -74,78 +73,78 @@ const bool isName(const value& token) { bool testReadXML() { { - std::istringstream is(customerXML); + istringstream is(customerXML); const list<value> c = readXML(streamList(is)); } { - std::istringstream is(currencyXML); + istringstream is(currencyXML); const list<value> c = readXML(streamList(is)); const value composite = car(c); assert(isTaggedList(composite, element)); assert(elementName(composite) == "composite"); - assert(attributeValue(car(filter<value>(isName, elementChildren(composite)))) == std::string("currency")); + assert(attributeValue(car(filter<value>(isName, elementChildren(composite)))) == string("currency")); } return true; } -std::ostringstream* xmlWriter(const std::string& s, std::ostringstream* os) { +ostream* xmlWriter(const string& s, ostream* os) { (*os) << s; return os; } bool testWriteXML() { { - std::istringstream is(customerXML); + istringstream is(customerXML); const list<value> c = readXML(streamList(is)); - std::ostringstream os; - writeXML<std::ostringstream*>(xmlWriter, &os, c); - assert(os.str() == customerXML); + ostringstream os; + writeXML<ostream*>(xmlWriter, &os, c); + assert(str(os) == customerXML); } { - std::istringstream is(currencyXML); + istringstream is(currencyXML); const list<value> c = readXML(streamList(is)); - std::ostringstream os; - writeXML<std::ostringstream*>(xmlWriter, &os, c); - assert(os.str() == currencyXML); + ostringstream os; + writeXML<ostream*>(xmlWriter, &os, c); + assert(str(os) == currencyXML); } return true; } bool testElement() { { - const list<value> ad = mklist<value>(mklist<value>("city", std::string("san francisco")), mklist<value>("state", std::string("ca"))); - const list<value> ac1 = mklist<value>(mklist<value>("id", std::string("1234")), mklist<value>("balance", 1000)); - const list<value> ac2 = mklist<value>(mklist<value>("id", std::string("6789")), mklist<value>("balance", 2000)); - const list<value> ac3 = mklist<value>(mklist<value>("id", std::string("4567")), mklist<value>("balance", 3000)); + const list<value> ad = mklist<value>(mklist<value>("city", string("san francisco")), mklist<value>("state", string("ca"))); + const list<value> ac1 = mklist<value>(mklist<value>("id", string("1234")), mklist<value>("balance", 1000)); + const list<value> ac2 = mklist<value>(mklist<value>("id", string("6789")), mklist<value>("balance", 2000)); + const list<value> ac3 = mklist<value>(mklist<value>("id", string("4567")), mklist<value>("balance", 3000)); { - const list<value> c = mklist<value>(mklist<value>("customer", mklist<value>("name", std::string("jdoe")), cons<value>("address", ad), mklist<value>("account", mklist<value>(ac1, ac2, ac3)))); + const list<value> c = mklist<value>(mklist<value>("customer", mklist<value>("name", string("jdoe")), cons<value>("address", ad), mklist<value>("account", mklist<value>(ac1, ac2, ac3)))); const list<value> e = valuesToElements(c); const list<value> v = elementsToValues(e); assert(v == c); - std::ostringstream os; - writeXML<std::ostringstream*>(xmlWriter, &os, e); - assert(os.str() == customerXML); + ostringstream os; + writeXML<ostream*>(xmlWriter, &os, e); + assert(str(os) == customerXML); } { - const list<value> c = mklist<value>(mklist<value>("customer", mklist<value>("name", std::string("jdoe")), cons<value>("address", ad), cons<value>("account", ac1), cons<value>("account", ac2), cons<value>("account", ac3))); + const list<value> c = mklist<value>(mklist<value>("customer", mklist<value>("name", string("jdoe")), cons<value>("address", ad), cons<value>("account", ac1), cons<value>("account", ac2), cons<value>("account", ac3))); const list<value> e = valuesToElements(c); const list<value> v = elementsToValues(e); - std::ostringstream os; - writeXML<std::ostringstream*>(xmlWriter, &os, e); - assert(os.str() == customerXML); + ostringstream os; + writeXML<ostream*>(xmlWriter, &os, e); + assert(str(os) == customerXML); } } { - std::istringstream is(customerXML); + istringstream is(customerXML); const list<value> c = readXML(streamList(is)); const list<value> v = elementsToValues(c); const list<value> e = valuesToElements(v); - std::ostringstream os; - writeXML<std::ostringstream*>(xmlWriter, &os, e); - assert(os.str() == customerXML); + ostringstream os; + writeXML<ostream*>(xmlWriter, &os, e); + assert(str(os) == customerXML); } return true; } @@ -153,13 +152,13 @@ bool testElement() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::testReadXML(); tuscany::testWriteXML(); tuscany::testElement(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/kernel/xml.hpp b/sca-cpp/trunk/kernel/xml.hpp index eee6e290d8..84cfc30475 100644 --- a/sca-cpp/trunk/kernel/xml.hpp +++ b/sca-cpp/trunk/kernel/xml.hpp @@ -30,9 +30,9 @@ #include <libxml/xmlwriter.h> #include <libxml/xmlschemas.h> #include <libxml/globals.h> -#include <string> +#include "string.hpp" #include "list.hpp" -#include "slist.hpp" +#include "stream.hpp" #include "value.hpp" #include "element.hpp" #include "monad.hpp" @@ -127,7 +127,7 @@ const value readIdentifier(XMLReader& reader) { */ const value readText(XMLReader& reader) { const char *val = (const char*)xmlTextReaderConstValue(reader); - return std::string(val); + return string(val); } /** @@ -136,7 +136,7 @@ const value readText(XMLReader& reader) { const value readAttribute(XMLReader& reader) { const char *name = (const char*)xmlTextReaderConstName(reader); const char *val = (const char*)xmlTextReaderConstValue(reader); - return mklist<value>(attribute, name, std::string(val)); + return mklist<value>(attribute, name, string(val)); } /** @@ -186,9 +186,9 @@ const list<value> read(XMLReader& reader) { */ class XMLReadContext { public: - XMLReadContext(const list<std::string>& ilist) : ilist(ilist) { + XMLReadContext(const list<string>& ilist) : ilist(ilist) { } - list<std::string> ilist; + list<string> ilist; }; /** @@ -198,17 +198,17 @@ int readCallback(void *context, char* buffer, int len) { XMLReadContext& rc = *static_cast<XMLReadContext*>(context); if (isNil(rc.ilist)) return 0; - rc.ilist = fragment(rc.ilist, len); - std::string s = car(rc.ilist); - rc.ilist = cdr(rc.ilist); - s.copy(buffer, s.length()); - return s.length(); + const list<string> f(fragment(rc.ilist, len)); + const string s(car(f)); + rc.ilist = cdr(f); + memcpy(buffer, c_str(s), length(s)); + return length(s); } /** - * Read a list values from a list of strings representing an XML document. + * Read a list of values from a list of strings representing an XML document. */ -const list<value> readXML(const list<std::string>& ilist) { +const list<value> readXML(const list<string>& ilist) { XMLReadContext cx(ilist); xmlTextReaderPtr xml = xmlReaderForIO(readCallback, NULL, &cx, NULL, NULL, XML_PARSE_NONET); if (xml == NULL) @@ -232,15 +232,15 @@ const list<value> expandElementValues(const value& n, const list<value>& l) { return cons<value>(value(cons<value>(element, cons<value>(n, (list<value>)car(l)))), expandElementValues(n, cdr(l))); } -const failable<bool, std::string> writeList(const list<value>& l, const xmlTextWriterPtr xml) { +const failable<bool> writeList(const list<value>& l, const xmlTextWriterPtr xml) { if (isNil(l)) return true; // Write an attribute const value token(car(l)); if (isTaggedList(token, attribute)) { - if (xmlTextWriterWriteAttribute(xml, (const xmlChar*)std::string(attributeName(token)).c_str(), (const xmlChar*)std::string(attributeValue(token)).c_str()) < 0) - return mkfailure<bool, std::string>("xmlTextWriterWriteAttribute failed"); + if (xmlTextWriterWriteAttribute(xml, (const xmlChar*)c_str(string(attributeName(token))), (const xmlChar*)c_str(string(attributeValue(token)))) < 0) + return mkfailure<bool>("xmlTextWriterWriteAttribute failed"); } else if (isTaggedList(token, element)) { @@ -256,38 +256,37 @@ const failable<bool, std::string> writeList(const list<value>& l, const xmlTextW } else { // Write an element with a single value - if (xmlTextWriterStartElement(xml, (const xmlChar*)std::string(elementName(token)).c_str()) < 0) - return mkfailure<bool, std::string>("xmlTextWriterStartElement failed"); + if (xmlTextWriterStartElement(xml, (const xmlChar*)c_str(string(elementName(token)))) < 0) + return mkfailure<bool>("xmlTextWriterStartElement failed"); // Write its children - const failable<bool, std::string> w = writeList(elementChildren(token), xml); + const failable<bool> w = writeList(elementChildren(token), xml); if (!hasContent(w)) return w; if (xmlTextWriterEndElement(xml) < 0) - return mkfailure<bool, std::string>("xmlTextWriterEndElement failed"); + return mkfailure<bool>("xmlTextWriterEndElement failed"); } } else { // Write an element - if (xmlTextWriterStartElement(xml, (const xmlChar*)std::string(elementName(token)).c_str()) < 0) - return mkfailure<bool, std::string>("xmlTextWriterStartElement failed"); + if (xmlTextWriterStartElement(xml, (const xmlChar*)c_str(string(elementName(token)))) < 0) + return mkfailure<bool>("xmlTextWriterStartElement failed"); // Write its children - const failable<bool, std::string> w = writeList(elementChildren(token), xml); + const failable<bool> w = writeList(elementChildren(token), xml); if (!hasContent(w)) return w; if (xmlTextWriterEndElement(xml) < 0) - return mkfailure<bool, std::string>("xmlTextWriterEndElement failed"); + return mkfailure<bool>("xmlTextWriterEndElement failed"); } } else { // Write XML text - if (xmlTextWriterWriteString(xml, (const xmlChar*)std::string(token).c_str()) < 0) - return mkfailure<bool, std::string>("xmlTextWriterWriteString failed"); - + if (xmlTextWriterWriteString(xml, (const xmlChar*)c_str(string(token))) < 0) + return mkfailure<bool>("xmlTextWriterWriteString failed"); } // Go on @@ -297,16 +296,16 @@ const failable<bool, std::string> writeList(const list<value>& l, const xmlTextW /** * Write a list of values to a libxml2 XML writer. */ -const failable<bool, std::string> write(const list<value>& l, const xmlTextWriterPtr xml) { +const failable<bool> write(const list<value>& l, const xmlTextWriterPtr xml) { if (xmlTextWriterStartDocument(xml, NULL, encoding, NULL) < 0) - return mkfailure<bool, std::string>("xmlTextWriterStartDocument failed"); + return mkfailure<bool>(string("xmlTextWriterStartDocument failed")); - const failable<bool, std::string> w = writeList(l, xml); + const failable<bool> w = writeList(l, xml); if (!hasContent(w)) return w; if (xmlTextWriterEndDocument(xml) < 0) - return mkfailure<bool, std::string>("xmlTextWriterEndDocument failed"); + return mkfailure<bool>("xmlTextWriterEndDocument failed"); return true; } @@ -315,9 +314,9 @@ const failable<bool, std::string> write(const list<value>& l, const xmlTextWrite */ template<typename R> class XMLWriteContext { public: - XMLWriteContext(const lambda<R(const std::string&, const R)>& reduce, const R& accum) : reduce(reduce), accum(accum) { + XMLWriteContext(const lambda<R(const string&, const R)>& reduce, const R& accum) : reduce(reduce), accum(accum) { } - const lambda<R(const std::string&, const R)> reduce; + const lambda<R(const string&, const R)> reduce; R accum; }; @@ -326,26 +325,26 @@ public: */ template<typename R> int writeCallback(void *context, const char* buffer, int len) { XMLWriteContext<R>& cx = *static_cast<XMLWriteContext<R>*>(context); - cx.accum = cx.reduce(std::string(buffer, len), cx.accum); + cx.accum = cx.reduce(string(buffer, len), cx.accum); return len; } /** * Convert a list of values to an XML document. */ -template<typename R> const failable<R, std::string> writeXML(const lambda<R(const std::string&, const R)>& reduce, const R& initial, const list<value>& l) { +template<typename R> const failable<R> writeXML(const lambda<R(const string&, const R)>& reduce, const R& initial, const list<value>& l) { XMLWriteContext<R> cx(reduce, initial); xmlOutputBufferPtr out = xmlOutputBufferCreateIO(writeCallback<R>, NULL, &cx, NULL); if (out == NULL) - return mkfailure<R, std::string>("xmlOutputBufferCreateIO failed"); + return mkfailure<R>("xmlOutputBufferCreateIO failed"); xmlTextWriterPtr xml = xmlNewTextWriter(out); if (xml == NULL) - return mkfailure<R, std::string>("xmlNewTextWriter failed"); + return mkfailure<R>("xmlNewTextWriter failed"); - const failable<bool, std::string> w = write(l, xml); + const failable<bool> w = write(l, xml); xmlFreeTextWriter(xml); if (!hasContent(w)) { - return mkfailure<R, std::string>(reason(w)); + return mkfailure<R>(reason(w)); } return cx.accum; } @@ -353,11 +352,11 @@ template<typename R> const failable<R, std::string> writeXML(const lambda<R(cons /** * Convert a list of values to a list of strings representing an XML document. */ -const failable<list<std::string>, std::string> writeXML(const list<value>& l) { - const failable<list<std::string>, std::string> ls = writeXML<list<std::string> >(rcons<std::string>, list<std::string>(), l); +const failable<list<string> > writeXML(const list<value>& l) { + const failable<list<string> > ls = writeXML<list<string> >(rcons<string>, list<string>(), l); if (!hasContent(ls)) return ls; - return reverse(list<std::string>(content(ls))); + return reverse(list<string>(content(ls))); } } diff --git a/sca-cpp/trunk/kernel/xsd-test.cpp b/sca-cpp/trunk/kernel/xsd-test.cpp index 818c03ba68..0fc432c649 100644 --- a/sca-cpp/trunk/kernel/xsd-test.cpp +++ b/sca-cpp/trunk/kernel/xsd-test.cpp @@ -23,8 +23,8 @@ * Test validation of a composite file against an SCDL schema. */ -#include <iostream> -#include <string> +#include "string.hpp" +#include "fstream.hpp" #include <libxml/xmlreader.h> #include <libxml/xmlschemas.h> @@ -35,12 +35,12 @@ bool printNode(xmlTextReaderPtr reader) { if(name == NULL) name = (xmlChar *)"<unknown>"; const xmlChar* value = xmlTextReaderConstValue(reader); - std::cout << xmlTextReaderDepth(reader) << " " << xmlTextReaderNodeType(reader) << " " << name << " " + cout << xmlTextReaderDepth(reader) << " " << xmlTextReaderNodeType(reader) << " " << name << " " << xmlTextReaderIsEmptyElement(reader) << " " << xmlTextReaderHasValue(reader); if(value == NULL) - std::cout << std::endl; + cout << endl; else - std::cout << value << std::endl; + cout << value << endl; return true; } @@ -54,13 +54,13 @@ int xmlClose(void *context) { } bool readFile(const char*xsdfilename, const char *filename) { - std::cout << "Loading schemas...\n"; + cout << "Loading schemas...\n"; const xmlDocPtr xsddoc = xmlReadFile(xsdfilename, NULL, XML_PARSE_NONET); const xmlSchemaParserCtxtPtr xsdctx = xmlSchemaNewDocParserCtxt(xsddoc); const xmlSchemaPtr xsd = xmlSchemaParse(xsdctx); const xmlSchemaValidCtxtPtr validctx = xmlSchemaNewValidCtxt(xsd); - std::cout << "Reading file...\n"; + cout << "Reading file...\n"; FILE* file = fopen(filename, "r"); if (file != NULL) { const xmlTextReaderPtr reader = xmlReaderForIO(xmlRead, xmlClose, file, filename, NULL, XML_PARSE_NONET); @@ -75,14 +75,14 @@ bool readFile(const char*xsdfilename, const char *filename) { printNode(reader); } if(xmlTextReaderIsValid(reader) != 1) - std::cout << "Could not validate document" << std::endl; + cout << "Could not validate document" << endl; xmlFreeTextReader(reader); if(rc != 0) - std::cout << "Could not parse document" << std::endl; + cout << "Could not parse document" << endl; } else - std::cout << "Could not create parser" << std::endl; + cout << "Could not create parser" << endl; } else - std::cout << "Could not open document" << std::endl; + cout << "Could not open document" << endl; xmlSchemaFreeValidCtxt(validctx); xmlSchemaFree(xsd); @@ -94,7 +94,7 @@ bool readFile(const char*xsdfilename, const char *filename) { } int main(int argc, char **argv) { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; if(argc != 3) return 1; @@ -102,6 +102,6 @@ int main(int argc, char **argv) { xmlCleanupParser(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/Makefile.am b/sca-cpp/trunk/modules/Makefile.am index 44ddf85de4..3b2d60b93a 100644 --- a/sca-cpp/trunk/modules/Makefile.am +++ b/sca-cpp/trunk/modules/Makefile.am @@ -15,7 +15,7 @@ # specific language governing permissions and limitations # under the License. -SUBDIRS = atom eval http json scdl server +SUBDIRS = atom eval json scdl http server includedir = $(prefix)/include/modules nobase_include_HEADERS = */*.hpp diff --git a/sca-cpp/trunk/modules/atom/atom-test.cpp b/sca-cpp/trunk/modules/atom/atom-test.cpp index ba651e8eb2..560c383a23 100644 --- a/sca-cpp/trunk/modules/atom/atom-test.cpp +++ b/sca-cpp/trunk/modules/atom/atom-test.cpp @@ -24,21 +24,19 @@ */ #include <assert.h> -#include <iostream> -#include <sstream> -#include <string> -#include "slist.hpp" +#include "stream.hpp" +#include "string.hpp" #include "atom.hpp" namespace tuscany { namespace atom { -std::ostringstream* writer(const std::string& s, std::ostringstream* os) { +ostream* writer(const string& s, ostream* os) { (*os) << s; return os; } -std::string itemEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +string itemEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<entry xmlns=\"http://www.w3.org/2005/Atom\">" "<title type=\"text\">item</title>" "<id>cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b</id>" @@ -50,7 +48,7 @@ std::string itemEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<link href=\"cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b\"/>" "</entry>\n"); -std::string incompleteEntry("<entry xmlns=\"http://www.w3.org/2005/Atom\">" +string incompleteEntry("<entry xmlns=\"http://www.w3.org/2005/Atom\">" "<title>item</title><content type=\"text/xml\">" "<Item xmlns=\"http://services/\">" "<name xmlns=\"\">Orange</name>" @@ -59,7 +57,7 @@ std::string incompleteEntry("<entry xmlns=\"http://www.w3.org/2005/Atom\">" "</content>" "</entry>"); -std::string completedEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +string completedEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<entry xmlns=\"http://www.w3.org/2005/Atom\">" "<title type=\"text\">item</title>" "<id></id>" @@ -73,36 +71,36 @@ std::string completedEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" bool testEntry() { { - const list<value> i = list<value>() << element << "item" - << (list<value>() << element << "name" << std::string("Apple")) - << (list<value>() << element << "price" << std::string("$2.99")); - const list<value> a = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); - std::ostringstream os; - writeATOMEntry<std::ostringstream*>(writer, &os, a); - assert(os.str() == itemEntry); + const list<value> i = list<value>() + element + value("item") + + value(list<value>() + element + value("name") + value(string("Apple"))) + + value(list<value>() + element + value("price") + value(string("$2.99"))); + const list<value> a = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + ostringstream os; + writeATOMEntry<ostream*>(writer, &os, a); + assert(str(os) == itemEntry); } { const list<value> a = content(readEntry(mklist(itemEntry))); - std::ostringstream os; - writeATOMEntry<std::ostringstream*>(writer, &os, a); - assert(os.str() == itemEntry); + ostringstream os; + writeATOMEntry<ostream*>(writer, &os, a); + assert(str(os) == itemEntry); } { const list<value> a = content(readEntry(mklist(incompleteEntry))); - std::ostringstream os; - writeATOMEntry<std::ostringstream*>(writer, &os, a); - assert(os.str() == completedEntry); + ostringstream os; + writeATOMEntry<ostream*>(writer, &os, a); + assert(str(os) == completedEntry); } return true; } -std::string emptyFeed("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +string emptyFeed("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<feed xmlns=\"http://www.w3.org/2005/Atom\">" "<title type=\"text\">Feed</title>" "<id>1234</id>" "</feed>\n"); -std::string itemFeed("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +string itemFeed("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<feed xmlns=\"http://www.w3.org/2005/Atom\">" "<title type=\"text\">Feed</title>" "<id>1234</id>" @@ -130,51 +128,51 @@ std::string itemFeed("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" bool testFeed() { { - std::ostringstream os; - writeATOMFeed<std::ostringstream*>(writer, &os, mklist<value>("Feed", "1234")); - assert(os.str() == emptyFeed); + ostringstream os; + writeATOMFeed<ostream*>(writer, &os, mklist<value>("Feed", "1234")); + assert(str(os) == emptyFeed); } { const list<value> a = content(readFeed(mklist(emptyFeed))); - std::ostringstream os; - writeATOMFeed<std::ostringstream*>(writer, &os, a); - assert(os.str() == emptyFeed); + ostringstream os; + writeATOMFeed<ostream*>(writer, &os, a); + assert(str(os) == emptyFeed); } { const list<value> i = list<value>() - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" - << (list<value>() << element << "item" - << (list<value>() << element << "name" << "Apple") - << (list<value>() << element << "price" << "$2.99"))) - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" - << (list<value>() << element << "item" - << (list<value>() << element << "name" << "Orange") - << (list<value>() << element << "price" << "$3.55"))); + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" + + (list<value>() + element + "item" + + (list<value>() + element + "name" + "Apple") + + (list<value>() + element + "price" + "$2.99"))) + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" + + (list<value>() + element + "item" + + (list<value>() + element + "name" + "Orange") + + (list<value>() + element + "price" + "$3.55"))); const list<value> a = cons<value>("Feed", cons<value>("1234", i)); - std::ostringstream os; - writeATOMFeed<std::ostringstream*>(writer, &os, a); - assert(os.str() == itemFeed); + ostringstream os; + writeATOMFeed<ostream*>(writer, &os, a); + assert(str(os) == itemFeed); } { const list<value> i = list<value>() - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" - << valueToElement(list<value>() << "item" - << (list<value>() << "name" << "Apple") - << (list<value>() << "price" << "$2.99"))) - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" - << valueToElement(list<value>() << "item" - << (list<value>() << "name" << "Orange") - << (list<value>() << "price" << "$3.55"))); + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" + + valueToElement(list<value>() + "item" + + (list<value>() + "name" + "Apple") + + (list<value>() + "price" + "$2.99"))) + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" + + valueToElement(list<value>() + "item" + + (list<value>() + "name" + "Orange") + + (list<value>() + "price" + "$3.55"))); const list<value> a = cons<value>("Feed", cons<value>("1234", i)); - std::ostringstream os; - writeATOMFeed<std::ostringstream*>(writer, &os, a); - assert(os.str() == itemFeed); + ostringstream os; + writeATOMFeed<ostream*>(writer, &os, a); + assert(str(os) == itemFeed); } { const list<value> a = content(readFeed(mklist(itemFeed))); - std::ostringstream os; - writeATOMFeed<std::ostringstream*>(writer, &os, a); - assert(os.str() == itemFeed); + ostringstream os; + writeATOMFeed<ostream*>(writer, &os, a); + assert(str(os) == itemFeed); } return true; } @@ -183,12 +181,12 @@ bool testFeed() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::atom::testEntry(); tuscany::atom::testFeed(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/atom/atom.hpp b/sca-cpp/trunk/modules/atom/atom.hpp index 7e2eb66cd2..4dbf7c7728 100644 --- a/sca-cpp/trunk/modules/atom/atom.hpp +++ b/sca-cpp/trunk/modules/atom/atom.hpp @@ -26,7 +26,7 @@ * ATOM data conversion functions. */ -#include <string> +#include "string.hpp" #include "list.hpp" #include "value.hpp" #include "monad.hpp" @@ -40,9 +40,9 @@ namespace atom { */ const list<value> entryValues(const list<value>& e) { const list<value> lt = filter<value>(selector(mklist<value>(element, "title")), e); - const value t = isNil(lt)? value(std::string("")) : elementValue(car(lt)); + const value t = isNil(lt)? value(emptyString) : elementValue(car(lt)); const list<value> li = filter<value>(selector(mklist<value>(element, "id")), e); - const value i = isNil(li)? value(std::string("")) : elementValue(car(li)); + const value i = isNil(li)? value(emptyString) : elementValue(car(li)); const list<value> lc = filter<value>(selector(mklist<value>(element, "content")), e); return mklist<value>(t, i, cadr(elementChildren(car(lc)))); } @@ -59,10 +59,10 @@ const list<value> entriesValues(const list<value>& e) { /** * Convert a list of strings to a list of values representing an ATOM entry. */ -const failable<list<value>, std::string> readEntry(const list<std::string>& ilist) { +const failable<list<value> > readEntry(const list<string>& ilist) { const list<value> e = readXML(ilist); if (isNil(e)) - return mkfailure<list<value>, std::string>("Empty entry"); + return mkfailure<list<value> >("Empty entry"); return entryValues(car(e)); } @@ -77,10 +77,10 @@ const value entryValue(const list<value>& e) { /** * Convert a list of strings to a list of values representing an ATOM feed. */ -const failable<list<value>, std::string> readFeed(const list<std::string>& ilist) { +const failable<list<value> > readFeed(const list<string>& ilist) { const list<value> f = readXML(ilist); if (isNil(f)) - return mkfailure<list<value>, std::string>("Empty feed"); + return mkfailure<list<value> >("Empty feed"); const list<value> t = filter<value>(selector(mklist<value>(element, "title")), car(f)); const list<value> i = filter<value>(selector(mklist<value>(element, "id")), car(f)); const list<value> e = filter<value>(selector(mklist<value>(element, "entry")), car(f)); @@ -95,11 +95,11 @@ const failable<list<value>, std::string> readFeed(const list<std::string>& ilist */ const list<value> entryElement(const list<value>& l) { return list<value>() - << element << "entry" << (list<value>() << attribute << "xmlns" << "http://www.w3.org/2005/Atom") - << (list<value>() << element << "title" << (list<value>() << attribute << "type" << "text") << car(l)) - << (list<value>() << element << "id" << cadr(l)) - << (list<value>() << element << "content" << (list<value>() << attribute << "type" << "application/xml") << caddr(l)) - << (list<value>() << element << "link" << (list<value>() << attribute << "href" << cadr(l))); + + element + "entry" + (list<value>() + attribute + "xmlns" + "http://www.w3.org/2005/Atom") + + (list<value>() + element + "title" + (list<value>() + attribute + "type" + "text") + car(l)) + + (list<value>() + element + "id" + cadr(l)) + + (list<value>() + element + "content" + (list<value>() + attribute + "type" + "application/xml") + caddr(l)) + + (list<value>() + element + "link" + (list<value>() + attribute + "href" + cadr(l))); } /** @@ -115,26 +115,26 @@ const list<value> entriesElements(const list<value>& l) { * Convert a list of values representing an ATOM entry to an ATOM entry. * The first two values in the list are the entry id and title. */ -template<typename R> const failable<R, std::string> writeATOMEntry(const lambda<R(const std::string&, const R)>& reduce, const R& initial, const list<value>& l) { +template<typename R> const failable<R> writeATOMEntry(const lambda<R(const string&, const R)>& reduce, const R& initial, const list<value>& l) { return writeXML<R>(reduce, initial, mklist<value>(entryElement(l))); } -const failable<list<std::string>, std::string> writeATOMEntry(const list<value>& l) { - const failable<list<std::string>, std::string> ls = writeATOMEntry<list<std::string> >(rcons<std::string>, list<std::string>(), l); +const failable<list<string> > writeATOMEntry(const list<value>& l) { + const failable<list<string> > ls = writeATOMEntry<list<string> >(rcons<string>, list<string>(), l); if (!hasContent(ls)) return ls; - return reverse(list<std::string>(content(ls))); + return reverse(list<string>(content(ls))); } /** * Convert a list of values representing an ATOM feed to an ATOM feed. * The first two values in the list are the feed id and title. */ -template<typename R> const failable<R, std::string> writeATOMFeed(const lambda<R(const std::string&, const R)>& reduce, const R& initial, const list<value>& l) { +template<typename R> const failable<R> writeATOMFeed(const lambda<R(const string&, const R)>& reduce, const R& initial, const list<value>& l) { const list<value> f = list<value>() - << element << "feed" << (list<value>() << attribute << "xmlns" << "http://www.w3.org/2005/Atom") - << (list<value>() << element << "title" << (list<value>() << attribute << "type" << "text") << car(l)) - << (list<value>() << element << "id" << cadr(l)); + + element + "feed" + (list<value>() + attribute + "xmlns" + "http://www.w3.org/2005/Atom") + + (list<value>() + element + "title" + (list<value>() + attribute + "type" + "text") + car(l)) + + (list<value>() + element + "id" + cadr(l)); if (isNil(cddr(l))) return writeXML<R>(reduce, initial, mklist<value>(f)); const list<value> fe = append(f, entriesElements(cddr(l))); @@ -145,11 +145,11 @@ template<typename R> const failable<R, std::string> writeATOMFeed(const lambda<R * Convert a list of values representing an ATOM feed to a list of strings. * The first two values in the list are the feed id and title. */ -const failable<list<std::string>, std::string> writeATOMFeed(const list<value>& l) { - const failable<list<std::string>, std::string> ls = writeATOMFeed<list<std::string> >(rcons<std::string>, list<std::string>(), l); +const failable<list<string> > writeATOMFeed(const list<value>& l) { + const failable<list<string> > ls = writeATOMFeed<list<string>>(rcons<string>, list<string>(), l); if (!hasContent(ls)) return ls; - return reverse(list<std::string>(content(ls))); + return reverse(list<string>(content(ls))); } /** diff --git a/sca-cpp/trunk/modules/eval/driver.hpp b/sca-cpp/trunk/modules/eval/driver.hpp index 3076e677c4..2d1badf501 100644 --- a/sca-cpp/trunk/modules/eval/driver.hpp +++ b/sca-cpp/trunk/modules/eval/driver.hpp @@ -26,34 +26,34 @@ * Script evaluator main driver loop. */ -#include <string> -#include <iostream> +#include "string.hpp" +#include "stream.hpp" #include "eval.hpp" namespace tuscany { namespace eval { -const std::string evalOutputPrompt("; "); -const std::string evalInputPrompt("=> "); +const string evalOutputPrompt("; "); +const string evalInputPrompt("=> "); -const bool promptForInput(const std::string str, std::ostream& out) { - out << std::endl << std::endl << str; +const bool promptForInput(const string& str, ostream& out) { + out << endl << endl << str; return true; } -const bool announceOutput(const std::string str, std::ostream& out) { - out << std::endl << str; +const bool announceOutput(const string str, ostream& out) { + out << endl << str; return true; } -const bool userPrint(const value val, std::ostream& out) { +const bool userPrint(const value val, ostream& out) { if(isCompoundProcedure(val)) writeValue(mklist<value>(compoundProcedureSymbol, procedureParameters(val), procedureBody(val), "<procedure-env>"), out); writeValue(val, out); return true; } -const value evalDriverLoop(std::istream& in, std::ostream& out, Env& globalEnv, const gc_pool& pool) { +const value evalDriverLoop(istream& in, ostream& out, Env& globalEnv, const gc_pool& pool) { promptForInput(evalInputPrompt, out); value input = readValue(in); if (isNil(input)) @@ -64,8 +64,7 @@ const value evalDriverLoop(std::istream& in, std::ostream& out, Env& globalEnv, return evalDriverLoop(in, out, globalEnv, pool); } -const bool evalDriverRun(std::istream& in, std::ostream& out) { - gc_pool pool; +const bool evalDriverRun(istream& in, ostream& out, const gc_pool& pool) { setupDisplay(out); Env globalEnv = setupEnvironment(pool); evalDriverLoop(in, out, globalEnv, pool); diff --git a/sca-cpp/trunk/modules/eval/environment.hpp b/sca-cpp/trunk/modules/eval/environment.hpp index 3a19c01deb..29bb3b64da 100644 --- a/sca-cpp/trunk/modules/eval/environment.hpp +++ b/sca-cpp/trunk/modules/eval/environment.hpp @@ -26,10 +26,11 @@ * Script evaluator environment implementation. */ -#include <string> +#include "string.hpp" #include "list.hpp" #include "value.hpp" #include "primitive.hpp" +#include <string> namespace tuscany { namespace eval { @@ -63,7 +64,7 @@ const Env enclosingEnvironment(const Env& env) { return cdr(env); } -const gc_pool_ptr<Frame> firstFrame(const Env& env) { +const gc_ptr<Frame> firstFrame(const Env& env) { return car(env); } @@ -82,7 +83,7 @@ const bool isDotVariable(const value& var) { const Frame makeBinding(const Frame& frameSoFar, const list<value>& variables, const list<value> values) { if (isNil(variables)) { if (!isNil(values)) - logStream() << "Too many arguments supplied " << values << std::endl; + logStream() << "Too many arguments supplied " << values << endl; return frameSoFar; } if (isDotVariable(car(variables))) @@ -90,7 +91,7 @@ const Frame makeBinding(const Frame& frameSoFar, const list<value>& variables, c if (isNil(values)) { if (!isNil(variables)) - logStream() << "Too few arguments supplied " << variables << std::endl; + logStream() << "Too few arguments supplied " << variables << endl; return frameSoFar; } @@ -101,8 +102,8 @@ const Frame makeBinding(const Frame& frameSoFar, const list<value>& variables, c return makeBinding(newFrame, cdr(variables), cdr(values)); } -const gc_pool_ptr<Frame> makeFrame(const list<value>& variables, const list<value> values, const gc_pool& pool) { - gc_pool_ptr<Frame> frame = gc_pool_new<Frame>(pool); +const gc_ptr<Frame> makeFrame(const list<value>& variables, const list<value> values, const gc_pool& pool) { + gc_ptr<Frame> frame = new (gc_new<Frame>(pool)) Frame(); *frame = value(makeBinding(cons(value(list<value>()), list<value>()), variables, values)); return frame; } @@ -163,7 +164,7 @@ const value lookupEnvScan(const value& var, const list<value>& vars, const list< const value lookupEnvLoop(const value& var, const Env& env) { if(env == theEmptyEnvironment()) { - logStream() << "Unbound variable " << var << std::endl; + logStream() << "Unbound variable " << var << endl; return value(); } return lookupEnvScan(var, frameVariables(*firstFrame(env)), frameValues(*firstFrame(env)), env); diff --git a/sca-cpp/trunk/modules/eval/eval-shell.cpp b/sca-cpp/trunk/modules/eval/eval-shell.cpp index e1c90101da..f73ac61250 100644 --- a/sca-cpp/trunk/modules/eval/eval-shell.cpp +++ b/sca-cpp/trunk/modules/eval/eval-shell.cpp @@ -24,12 +24,13 @@ */ #include <assert.h> -#include <iostream> -#include <string> -#include <sstream> +#include "gc.hpp" +#include "stream.hpp" +#include "string.hpp" #include "driver.hpp" int main() { - tuscany::eval::evalDriverRun(std::cin, std::cout); + tuscany::gc_scoped_pool pool; + tuscany::eval::evalDriverRun(tuscany::cin, tuscany::cout, pool); return 0; } diff --git a/sca-cpp/trunk/modules/eval/eval-test.cpp b/sca-cpp/trunk/modules/eval/eval-test.cpp index fb755b9077..3cf16f602f 100644 --- a/sca-cpp/trunk/modules/eval/eval-test.cpp +++ b/sca-cpp/trunk/modules/eval/eval-test.cpp @@ -24,16 +24,15 @@ */ #include <assert.h> -#include <iostream> -#include <string> -#include <sstream> +#include "stream.hpp" +#include "string.hpp" #include "driver.hpp" namespace tuscany { namespace eval { bool testEnv() { - gc_pool pool; + gc_scoped_pool pool; Env globalEnv = list<value>(); Env env = extendEnvironment(mklist<value>("a"), mklist<value>(1), globalEnv, pool); defineVariable("x", env, env); @@ -50,26 +49,23 @@ bool testEnvGC() { assert(checkValueCounters()); assert(checkLambdaCounters()); assert(checkListCounters()); - //printLambdaCounters(); - //printListCounters(); - //printValueCounters(); return true; } bool testRead() { - std::istringstream is("abcd"); + istringstream is("abcd"); assert(readValue(is) == "abcd"); - std::istringstream is2("123"); + istringstream is2("123"); assert(readValue(is2) == value(123)); - std::istringstream is3("(abcd)"); + istringstream is3("(abcd)"); assert(readValue(is3) == mklist(value("abcd"))); - std::istringstream is4("(abcd xyz)"); + istringstream is4("(abcd xyz)"); assert(readValue(is4) == mklist<value>("abcd", "xyz")); - std::istringstream is5("(abcd (xyz tuv))"); + istringstream is5("(abcd (xyz tuv))"); assert(readValue(is5) == mklist<value>("abcd", mklist<value>("xyz", "tuv"))); return true; @@ -77,43 +73,43 @@ bool testRead() { bool testWrite() { const list<value> i = list<value>() - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" - << (list<value>() << "item" - << (list<value>() << "name" << "Apple") - << (list<value>() << "price" << "$2.99"))) - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" - << (list<value>() << "item" - << (list<value>() << "name" << "Orange") - << (list<value>() << "price" << "$3.55"))); + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" + + (list<value>() + "item" + + (list<value>() + "name" + "Apple") + + (list<value>() + "price" + "$2.99"))) + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" + + (list<value>() + "item" + + (list<value>() + "name" + "Orange") + + (list<value>() + "price" + "$3.55"))); const list<value> a = cons<value>("Feed", cons<value>("feed-1234", i)); - std::ostringstream os; + ostringstream os; writeValue(a, os); - std::istringstream is(os.str()); + istringstream is(str(os)); assert(readValue(is) == a); return true; } -const std::string testSchemeNumber( +const string testSchemeNumber( "(define (testNumber) (if (= 1 1) (display \"testNumber ok\") (error \"testNumber\"))) " "(testNumber)"); -const std::string testSchemeString( +const string testSchemeString( "(define (testString) (if (= \"abc\" \"abc\") (display \"testString ok\") (error \"testString\"))) " "(testString)"); -const std::string testSchemeDefinition( +const string testSchemeDefinition( "(define a \"abc\") (define (testDefinition) (if (= a \"abc\") (display \"testDefinition ok\") (error \"testDefinition\"))) " "(testDefinition)"); -const std::string testSchemeIf( +const string testSchemeIf( "(define (testIf) (if (= \"abc\" \"abc\") (if (= \"xyz\" \"xyz\") (display \"testIf ok\") (error \"testNestedIf\")) (error \"testIf\"))) " "(testIf)"); -const std::string testSchemeCond( +const string testSchemeCond( "(define (testCond) (cond ((= \"abc\" \"abc\") (display \"testCond ok\")) (else (error \"testIf\"))))" "(testCond)"); -const std::string testSchemeBegin( +const string testSchemeBegin( "(define (testBegin) " "(begin " "(define a \"abc\") " @@ -124,42 +120,39 @@ const std::string testSchemeBegin( ") " "(testBegin)"); -const std::string testSchemeLambda( +const string testSchemeLambda( "(define sqrt (lambda (x) (* x x))) " "(define (testLambda) (if (= 4 (sqrt 2)) (display \"testLambda ok\") (error \"testLambda\"))) " "(testLambda)"); -const std::string testSchemeForward( +const string testSchemeForward( "(define (testLambda) (if (= 4 (sqrt 2)) (display \"testForward ok\") (error \"testForward\"))) " "(define sqrt (lambda (x) (* x x))) " "(testLambda)"); -bool contains(const std::string& str, const std::string& pattern) { - return str.find(pattern) != str.npos; -} - -const std::string evalOutput(const std::string& scm) { - std::istringstream is(scm); - std::ostringstream os; - evalDriverRun(is, os); - return os.str(); +const string evalOutput(const string& scm, const gc_pool& pool) { + istringstream is(scm); + ostringstream os; + evalDriverRun(is, os, pool); + return str(os); } bool testEval() { - assert(contains(evalOutput(testSchemeNumber), "testNumber ok")); - assert(contains(evalOutput(testSchemeString), "testString ok")); - assert(contains(evalOutput(testSchemeDefinition), "testDefinition ok")); - assert(contains(evalOutput(testSchemeIf), "testIf ok")); - assert(contains(evalOutput(testSchemeCond), "testCond ok")); - assert(contains(evalOutput(testSchemeBegin), "testBegin1 ok")); - assert(contains(evalOutput(testSchemeBegin), "testBegin2 ok")); - assert(contains(evalOutput(testSchemeLambda), "testLambda ok")); - assert(contains(evalOutput(testSchemeForward), "testForward ok")); + gc_scoped_pool pool; + assert(contains(evalOutput(testSchemeNumber, pool), "testNumber ok")); + assert(contains(evalOutput(testSchemeString, pool), "testString ok")); + assert(contains(evalOutput(testSchemeDefinition, pool), "testDefinition ok")); + assert(contains(evalOutput(testSchemeIf, pool), "testIf ok")); + assert(contains(evalOutput(testSchemeCond, pool), "testCond ok")); + assert(contains(evalOutput(testSchemeBegin, pool), "testBegin1 ok")); + assert(contains(evalOutput(testSchemeBegin, pool), "testBegin2 ok")); + assert(contains(evalOutput(testSchemeLambda, pool), "testLambda ok")); + assert(contains(evalOutput(testSchemeForward, pool), "testForward ok")); return true; } bool testEvalExpr() { - gc_pool pool; + gc_scoped_pool pool; const value exp = mklist<value>("+", 2, 3); Env env = setupEnvironment(pool); const value r = evalExpr(exp, env, pool); @@ -168,7 +161,8 @@ bool testEvalExpr() { } bool testEvalRun() { - evalDriverRun(std::cin, std::cout); + gc_scoped_pool pool; + evalDriverRun(cin, cout, pool); return true; } @@ -178,26 +172,26 @@ const value mult(const list<value>& args) { return x * y; } -const std::string testReturnLambda( +const string testReturnLambda( "(define (testReturnLambda) * )"); -const std::string testCallLambda( +const string testCallLambda( "(define (testCallLambda l x y) (l x y))"); bool testEvalLambda() { - gc_pool pool; + gc_scoped_pool pool; Env env = setupEnvironment(pool); const value trl = mklist<value>("testReturnLambda"); - std::istringstream trlis(testReturnLambda); + istringstream trlis(testReturnLambda); const value trlv = evalScript(trl, trlis, env, pool); - std::istringstream tclis(testCallLambda); + istringstream tclis(testCallLambda); const value tcl = cons<value>("testCallLambda", quotedParameters(mklist<value>(trlv, 2, 3))); const value tclv = evalScript(tcl, tclis, env, pool); assert(tclv == value(6)); - std::istringstream tcelis(testCallLambda); + istringstream tcelis(testCallLambda); const value tcel = cons<value>("testCallLambda", quotedParameters(mklist<value>(primitiveProcedure(mult), 3, 4))); const value tcelv = evalScript(tcel, tcelis, env, pool); assert(tcelv == value(12)); @@ -214,9 +208,6 @@ bool testEvalGC() { assert(checkValueCounters()); assert(checkLambdaCounters()); assert(checkListCounters()); - //printLambdaCounters(); - //printListCounters(); - //printValueCounters(); return true; } @@ -224,7 +215,7 @@ bool testEvalGC() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::eval::testEnv(); tuscany::eval::testEnvGC(); @@ -235,6 +226,6 @@ int main() { tuscany::eval::testEvalLambda(); tuscany::eval::testEvalGC(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/eval/eval.hpp b/sca-cpp/trunk/modules/eval/eval.hpp index 1b4d94c631..ea6e2da13a 100644 --- a/sca-cpp/trunk/modules/eval/eval.hpp +++ b/sca-cpp/trunk/modules/eval/eval.hpp @@ -146,7 +146,7 @@ const value applyProcedure(const value& procedure, list<value>& arguments, const Env env = extendEnvironment(procedureParameters(procedure), arguments, procedureEnvironment(procedure), pool); return evalSequence(procedureBody(procedure), env, pool); } - logStream() << "Unknown procedure type " << procedure << std::endl; + logStream() << "Unknown procedure type " << procedure << endl; return value(); } @@ -208,7 +208,7 @@ const value expandClauses(const list<value>& clauses) { if(isCondElseClause(first)) { if(isNil(rest)) return sequenceToExp(condActions(first)); - logStream() << "else clause isn't last " << clauses << std::endl; + logStream() << "else clause isn't last " << clauses << endl; return value(); } return makeIf(condPredicate(first), sequenceToExp(condActions(first)), expandClauses(rest)); @@ -254,7 +254,7 @@ const value evalExpr(const value& exp, Env& env, const gc_pool& pool) { list<value> operandValues = listOfValues(operands(exp), env, pool); return applyProcedure(evalExpr(operat(exp), env, pool), operandValues, pool); } - logStream() << "Unknown expression type " << exp << std::endl; + logStream() << "Unknown expression type " << exp << endl; return value(); } @@ -281,7 +281,7 @@ const value evalScript(const value& expr, const value& script, Env& env, const g /** * Evaluate an expression against a script provided as an input stream. */ -const value evalScript(const value& expr, std::istream& is, Env& env, const gc_pool& pool) { +const value evalScript(const value& expr, istream& is, Env& env, const gc_pool& pool) { return evalScript(expr, readScript(is), env, pool); } diff --git a/sca-cpp/trunk/modules/eval/io.hpp b/sca-cpp/trunk/modules/eval/io.hpp index 53657ce055..0c2abb3af9 100644 --- a/sca-cpp/trunk/modules/eval/io.hpp +++ b/sca-cpp/trunk/modules/eval/io.hpp @@ -26,10 +26,9 @@ * Script evaluator IO functions. */ -#include <iostream> -#include <string> -#include <sstream> #include <ctype.h> +#include "stream.hpp" +#include "string.hpp" #include "list.hpp" #include "value.hpp" @@ -42,11 +41,8 @@ const value rightParenthesis(mklist<value>(")")); const value leftParenthesis(mklist<value>("(")); const value comment(mklist<value>(";")); -const double stringToNumber(const std::string& str) { - double d; - std::istringstream is(str); - is >> d; - return d; +const double stringToNumber(const string& str) { + return atof(c_str(str)); } const bool isWhitespace(const char ch) { @@ -73,18 +69,18 @@ const bool isRightParenthesis(const value& token) { return rightParenthesis == token; } -const char readChar(std::istream& in) { +const char readChar(istream& in) { if(in.eof()) { return -1; } - char c = (char)in.get(); + char c = (char)get(in); return c; } -const char peekChar(std::istream& in) { - if(in.eof()) +const char peekChar(istream& in) { + if(eof(in)) return -1; - char c = (char)in.peek(); + char c = (char)peek(in); return c; } @@ -92,14 +88,14 @@ const bool isQuote(const value& token) { return token == quoteSymbol; } -const value skipComment(std::istream& in); -const value readQuoted(std::istream& in); -const value readIdentifier(const char chr, std::istream& in); -const value readString(std::istream& in); -const value readNumber(const char chr, std::istream& in); -const value readValue(std::istream& in); +const value skipComment(istream& in); +const value readQuoted(istream& in); +const value readIdentifier(const char chr, istream& in); +const value readString(istream& in); +const value readNumber(const char chr, istream& in); +const value readValue(istream& in); -const value readToken(std::istream& in) { +const value readToken(istream& in) { const char firstChar = readChar(in); if(isWhitespace(firstChar)) return readToken(in); @@ -119,22 +115,22 @@ const value readToken(std::istream& in) { return readNumber(firstChar, in); if(firstChar == -1) return value(); - logStream() << "Illegal lexical syntax '" << firstChar << "'" << std::endl; + logStream() << "Illegal lexical syntax '" << firstChar << "'" << endl; return readToken(in); } -const value skipComment(std::istream& in) { +const value skipComment(istream& in) { const char nextChar = readChar(in); if (nextChar == '\n') return readToken(in); return skipComment(in); } -const value readQuoted(std::istream& in) { +const value readQuoted(istream& in) { return mklist(quoteSymbol, readValue(in)); } -const list<value> readList(const list<value>& listSoFar, std::istream& in) { +const list<value> readList(const list<value>& listSoFar, istream& in) { const value token = readToken(in); if(isNil(token) || isRightParenthesis(token)) return reverse(listSoFar); @@ -143,72 +139,73 @@ const list<value> readList(const list<value>& listSoFar, std::istream& in) { return readList(cons(token, listSoFar), in); } -const std::string listToString(const list<char>& l) { +const string listToString(const list<char>& l) { if(isNil(l)) return ""; - return car(l) + listToString(cdr(l)); + const char buf[1] = { car(l) }; + return string(buf, 1) + listToString(cdr(l)); } -const list<char> readIdentifierHelper(const list<char>& listSoFar, std::istream& in) { +const list<char> readIdentifierHelper(const list<char>& listSoFar, istream& in) { const char nextChar = peekChar(in); if(isIdentifierPart(nextChar)) return readIdentifierHelper(cons(readChar(in), listSoFar), in); return reverse(listSoFar); } -const value readIdentifier(const char chr, std::istream& in) { - return listToString(readIdentifierHelper(mklist(chr), in)).c_str(); +const value readIdentifier(const char chr, istream& in) { + return c_str(listToString(readIdentifierHelper(mklist(chr), in))); } -const list<char> readStringHelper(const list<char>& listSoFar, std::istream& in) { +const list<char> readStringHelper(const list<char>& listSoFar, istream& in) { const char nextChar = readChar(in); if(nextChar != -1 && nextChar != '"') return readStringHelper(cons(nextChar, listSoFar), in); return reverse(listSoFar); } -const value readString(std::istream& in) { +const value readString(istream& in) { return listToString(readStringHelper(list<char>(), in)); } -const list<char> readNumberHelper(const list<char>& listSoFar, std::istream& in) { +const list<char> readNumberHelper(const list<char>& listSoFar, istream& in) { const char nextChar = peekChar(in); if(isDigit(nextChar)) return readNumberHelper(cons(readChar(in), listSoFar), in); return reverse(listSoFar); } -const value readNumber(const char chr, std::istream& in) { +const value readNumber(const char chr, istream& in) { return stringToNumber(listToString(readNumberHelper(mklist(chr), in))); } -const value readValue(std::istream& in) { +const value readValue(istream& in) { const value nextToken = readToken(in); if(isLeftParenthesis(nextToken)) return readList(list<value> (), in); return nextToken; } -const value readValue(const std::string s) { - std::istringstream in(s); +const value readValue(const string s) { + istringstream in(s); const value nextToken = readToken(in); if(isLeftParenthesis(nextToken)) return readList(list<value> (), in); return nextToken; } -const bool writeValue(const value& val, std::ostream& out) { +const bool writeValue(const value& val, ostream& out) { out << val; return true; } -const std::string writeValue(const value& val) { - std::ostringstream out; +const string writeValue(const value& val) { + ostringstream out; out << val; - return out.str(); + return str(out); } -const value readScript(std::istream& in) { +const value readScript(istream& in) { const value val = readValue(in); if (isNil(val)) return list<value>(); diff --git a/sca-cpp/trunk/modules/eval/primitive.hpp b/sca-cpp/trunk/modules/eval/primitive.hpp index 37c53fdd0b..75d691c4ac 100644 --- a/sca-cpp/trunk/modules/eval/primitive.hpp +++ b/sca-cpp/trunk/modules/eval/primitive.hpp @@ -28,7 +28,7 @@ #include <apr_general.h> #include <apr_uuid.h> -#include <iostream> +#include "stream.hpp" #include "function.hpp" #include "list.hpp" #include "value.hpp" @@ -40,24 +40,24 @@ const value primitiveSymbol("primitive"); const value quoteSymbol("'"); const value lambdaSymbol("lambda"); -std::ostream* displayOutStream = &std::cout; -std::ostream* logOutStream = &std::cerr; +ostream* displayOutStream = &cout; +ostream* logOutStream = &cerr; -const bool setupDisplay(std::ostream& out) { +const bool setupDisplay(ostream& out) { displayOutStream = &out; return true; } -std::ostream& displayStream() { +ostream& displayStream() { return *displayOutStream; } -const bool setupLog(std::ostream& out) { +const bool setupLog(ostream& out) { logOutStream = &out; return true; } -std::ostream& logStream() { +ostream& logStream() { return *logOutStream; } @@ -116,7 +116,7 @@ const value divProc(const list<value>& args) { const value displayProc(const list<value>& args) { if (isNil(args)) { - displayStream() << std::endl; + displayStream() << endl; return true; } displayStream() << car(args); @@ -125,7 +125,7 @@ const value displayProc(const list<value>& args) { const value logProc(const list<value>& args) { if (isNil(args)) { - logStream() << std::endl; + logStream() << endl; return true; } logStream() << car(args); @@ -137,7 +137,7 @@ const value uuidProc(unused const list<value>& args) { apr_uuid_get(&uuid); char buf[APR_UUID_FORMATTED_LENGTH]; apr_uuid_format(buf, &uuid); - return std::string(buf, APR_UUID_FORMATTED_LENGTH); + return string(buf, APR_UUID_FORMATTED_LENGTH); } const value cadrProc(unused const list<value>& args) { @@ -194,51 +194,49 @@ template<typename F> const value primitiveProcedure(const F& f) { } const list<value> primitiveProcedureNames() { - list<value> l = mklist<value>("car"); - l = cons<value>("cdr", l); - l = cons<value>("cons", l); - l = cons<value>("list", l); - l = cons<value>("nul", l); - l = cons<value>("=", l); - l = cons<value>("equal?", l); - l = cons<value>("+", l); - l = cons<value>("-", l); - l = cons<value>("*", l); - l = cons<value>("/", l); - l = cons<value>("assoc", l); - l = cons<value>("cadr", l); - l = cons<value>("caddr", l); - l = cons<value>("cadddr", l); - l = cons<value>("cddr", l); - l = cons<value>("cdddr", l); - l = cons<value>("display", l); - l = cons<value>("log", l); - l = cons<value>("uuid", l); - return l; + return mklist<value>("car") + + "cdr" + + "cons" + + "list" + + "nul" + + "=" + + "equal?" + + "+" + + "-" + + "*" + + "/" + + "assoc" + + "cadr" + + "caddr" + + "cadddr" + + "cddr" + + "cdddr" + + "display" + + "log" + + "uuid"; } const list<value> primitiveProcedureObjects() { - list<value> l = mklist(primitiveProcedure(carProc)); - l = cons(primitiveProcedure(cdrProc), l); - l = cons(primitiveProcedure(consProc), l); - l = cons(primitiveProcedure(listProc), l); - l = cons(primitiveProcedure(nulProc), l); - l = cons(primitiveProcedure(equalProc), l); - l = cons(primitiveProcedure(equalProc), l); - l = cons(primitiveProcedure(addProc), l); - l = cons(primitiveProcedure(subProc), l); - l = cons(primitiveProcedure(mulProc), l); - l = cons(primitiveProcedure(divProc), l); - l = cons(primitiveProcedure(assocProc), l); - l = cons(primitiveProcedure(cadrProc), l); - l = cons(primitiveProcedure(caddrProc), l); - l = cons(primitiveProcedure(cadddrProc), l); - l = cons(primitiveProcedure(cddrProc), l); - l = cons(primitiveProcedure(cdddrProc), l); - l = cons(primitiveProcedure(displayProc), l); - l = cons(primitiveProcedure(logProc), l); - l = cons(primitiveProcedure(uuidProc), l); - return l; + return mklist(primitiveProcedure(carProc)) + + primitiveProcedure(cdrProc) + + primitiveProcedure(consProc) + + primitiveProcedure(listProc) + + primitiveProcedure(nulProc) + + primitiveProcedure(equalProc) + + primitiveProcedure(equalProc) + + primitiveProcedure(addProc) + + primitiveProcedure(subProc) + + primitiveProcedure(mulProc) + + primitiveProcedure(divProc) + + primitiveProcedure(assocProc) + + primitiveProcedure(cadrProc) + + primitiveProcedure(caddrProc) + + primitiveProcedure(cadddrProc) + + primitiveProcedure(cddrProc) + + primitiveProcedure(cdddrProc) + + primitiveProcedure(displayProc) + + primitiveProcedure(logProc) + + primitiveProcedure(uuidProc); } const bool isFalse(const value& exp) { diff --git a/sca-cpp/trunk/modules/http/curl-test.cpp b/sca-cpp/trunk/modules/http/curl-test.cpp index 01355dd429..4305d2ac38 100644 --- a/sca-cpp/trunk/modules/http/curl-test.cpp +++ b/sca-cpp/trunk/modules/http/curl-test.cpp @@ -24,21 +24,15 @@ */ #include <assert.h> -#include <iostream> -#include <sstream> -#include <string> -#include "slist.hpp" +#include "stream.hpp" +#include "string.hpp" #include "perf.hpp" #include "curl.hpp" namespace tuscany { namespace http { -const bool contains(const std::string& str, const std::string& pattern) { - return str.find(pattern) != str.npos; -} - -std::ostringstream* curlWriter(const std::string& s, std::ostringstream* os) { +ostream* curlWriter(const string& s, ostream* os) { (*os) << s; return os; } @@ -46,16 +40,16 @@ std::ostringstream* curlWriter(const std::string& s, std::ostringstream* os) { const bool testGet() { CURLSession ch; { - std::ostringstream os; - const failable<list<std::ostringstream*>, std::string> r = get<std::ostringstream*>(curlWriter, &os, "http://localhost:8090", ch); + ostringstream os; + const failable<list<ostream*> > r = get<ostream*>(curlWriter, &os, "http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(os.str(), "HTTP/1.1 200 OK")); - assert(contains(os.str(), "It works")); + assert(contains(str(os), "HTTP/1.1 200 OK")); + assert(contains(str(os), "It works")); } { - const failable<value, std::string> r = get("http://localhost:8090", ch); + const failable<value> r = getcontent("http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(content(r), "It works")); + assert(contains(car(reverse(list<value>(content(r)))), "It works")); } return true; } @@ -65,9 +59,9 @@ struct getLoop { getLoop(CURLSession& ch) : ch(ch) { } const bool operator()() const { - const failable<value, std::string> r = get("http://localhost:8090", ch); + const failable<value> r = getcontent("http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(content(r), "It works")); + assert(contains(car(reverse(list<value>(content(r)))), "It works")); return true; } }; @@ -75,7 +69,7 @@ struct getLoop { const bool testGetPerf() { CURLSession ch; lambda<bool()> gl = getLoop(ch); - std::cout << "Static GET test " << time(gl, 5, 200) << " ms" << std::endl; + cout << "Static GET test " << time(gl, 5, 200) << " ms" << endl; return true; } @@ -83,12 +77,12 @@ const bool testGetPerf() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::http::testGet(); tuscany::http::testGetPerf(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/http/curl.hpp b/sca-cpp/trunk/modules/http/curl.hpp index 85665c2785..3478a590fd 100644 --- a/sca-cpp/trunk/modules/http/curl.hpp +++ b/sca-cpp/trunk/modules/http/curl.hpp @@ -29,7 +29,7 @@ #include <curl/curl.h> #include <curl/types.h> #include <curl/easy.h> -#include <string> +#include "string.hpp" #include "gc.hpp" #include "list.hpp" #include "value.hpp" @@ -62,7 +62,7 @@ CURLContext curlContext; */ class CURLSession { public: - CURLSession() : ch(new CURLHandle()) { + CURLSession() : ch(new (gc_new<CURLHandle>()) CURLHandle()) { } ~CURLSession() { @@ -103,9 +103,9 @@ CURL* handle(const CURLSession& c) { */ class CURLReadContext { public: - CURLReadContext(const list<std::string>& ilist) : ilist(ilist) { + CURLReadContext(const list<string>& ilist) : ilist(ilist) { } - list<std::string> ilist; + list<string> ilist; }; /** @@ -115,11 +115,11 @@ size_t readCallback(void *ptr, size_t size, size_t nmemb, void *data) { CURLReadContext& rcx = *static_cast<CURLReadContext*>(data); if (isNil(rcx.ilist)) return 0; - rcx.ilist = fragment(rcx.ilist, size * nmemb); - const std::string s = car(rcx.ilist); - rcx.ilist = cdr(rcx.ilist); - s.copy((char*)ptr, s.length()); - return s.length(); + const list<string> f(fragment(rcx.ilist, size * nmemb)); + const string s = car(f); + rcx.ilist = cdr(f); + memcpy(ptr, c_str(s), length(s)); + return length(s); } /** @@ -127,9 +127,9 @@ size_t readCallback(void *ptr, size_t size, size_t nmemb, void *data) { */ template<typename R> class CURLWriteContext { public: - CURLWriteContext(const lambda<R(const std::string&, const R)>& reduce, const R& accum) : reduce(reduce), accum(accum) { + CURLWriteContext(const lambda<R(const string&, const R)>& reduce, const R& accum) : reduce(reduce), accum(accum) { } - const lambda<R(const std::string&, const R)> reduce; + const lambda<R(const string&, const R)> reduce; R accum; }; @@ -137,33 +137,23 @@ public: * Called by CURL to write received data. */ template<typename R> size_t writeCallback(void *ptr, size_t size, size_t nmemb, void *data) { - CURLWriteContext<R>& wcx = *(static_cast<CURLWriteContext<R>*> (data)); - const size_t realsize = size * nmemb; - wcx.accum = wcx.reduce(std::string((const char*)ptr, realsize), wcx.accum); - return realsize; -} - -/** - * Called by CURL to write received header data. - */ -template<typename R> size_t headerCallback(void *ptr, size_t size, size_t nmemb, void *data) { - CURLWriteContext<R>& wcx = *(static_cast<CURLWriteContext<R>*> (data)); - const size_t realsize = size * nmemb; - wcx.accum = wcx.reduce(std::string((const char*)ptr, realsize), wcx.accum); - return realsize; + CURLWriteContext<R>& wcx = *(static_cast<CURLWriteContext<R>*> (data)); + const size_t realsize = size * nmemb; + wcx.accum = wcx.reduce(string((const char*)ptr, realsize), wcx.accum); + return realsize; } /** * Apply an HTTP verb to a list containing a list of headers and a list of content, and * a reduce function used to process the response. */ -curl_slist* headers(curl_slist* cl, const list<std::string>& h) { +curl_slist* headers(curl_slist* cl, const list<string>& h) { if (isNil(h)) return cl; - return headers(curl_slist_append(cl, std::string(car(h)).c_str()), cdr(h)); + return headers(curl_slist_append(cl, c_str(string(car(h)))), cdr(h)); } -template<typename R> const failable<list<R>, std::string> apply(const list<list<std::string> >& req, const lambda<R(const std::string&, const R)>& reduce, const R& initial, const std::string& url, const std::string& verb, const CURLSession& cs) { +template<typename R> const failable<list<R> > apply(const list<list<string> >& hdr, const lambda<R(const string&, const R)>& reduce, const R& initial, const string& url, const string& verb, const CURLSession& cs) { // Init the curl session CURL* ch = handle(cs); @@ -171,30 +161,30 @@ template<typename R> const failable<list<R>, std::string> apply(const list<list< curl_easy_setopt(ch, CURLOPT_USERAGENT, "libcurl/1.0"); //TODO use HTTP chunking, for now just convert request to a single string - std::ostringstream os; - write(cadr(req), os); - const std::string s = os.str(); - const int sz = s.length(); + ostringstream os; + write(cadr(hdr), os); + const string s = str(os); + const int sz = length(s); // Setup the read, header and write callbacks CURLReadContext rcx(mklist(s)); curl_easy_setopt(ch, CURLOPT_READFUNCTION, (size_t (*)(void*, size_t, size_t, void*))readCallback); curl_easy_setopt(ch, CURLOPT_READDATA, &rcx); CURLWriteContext<R> hcx(reduce, initial); - curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, (size_t (*)(void*, size_t, size_t, void*))headerCallback<R>); + curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, (size_t (*)(void*, size_t, size_t, void*))(writeCallback<R>)); curl_easy_setopt(ch, CURLOPT_HEADERDATA, &hcx); CURLWriteContext<R> wcx(reduce, initial); - curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, (size_t (*)(void*, size_t, size_t, void*))writeCallback<R>); + curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, (size_t (*)(void*, size_t, size_t, void*))(writeCallback<R>)); curl_easy_setopt(ch, CURLOPT_WRITEDATA, &wcx); curl_easy_setopt(ch, CURLOPT_TCP_NODELAY, true); // Set the request headers - curl_slist* hl = headers(NULL, car(req)); + curl_slist* hl = headers(NULL, car(hdr)); if (hl != NULL) curl_easy_setopt(ch, CURLOPT_HTTPHEADER, hl); // Apply the HTTP verb - curl_easy_setopt(ch, CURLOPT_URL, url.c_str()); + curl_easy_setopt(ch, CURLOPT_URL, c_str(url)); if (verb == "POST") { curl_easy_setopt(ch, CURLOPT_POST, true); curl_easy_setopt(ch, CURLOPT_POSTFIELDSIZE, sz); @@ -210,13 +200,13 @@ template<typename R> const failable<list<R>, std::string> apply(const list<list< // Return the HTTP return code or content if (rc) - return mkfailure<list<R>, std::string>(curl_easy_strerror(rc)); + return mkfailure<list<R> >(string(curl_easy_strerror(rc))); long httprc; curl_easy_getinfo (ch, CURLINFO_RESPONSE_CODE, &httprc); if (httprc != 200 && httprc != 201) { - std::ostringstream es; + ostringstream es; es << "HTTP code " << httprc; - return mkfailure<list<R>, std::string>(es.str()); + return mkfailure<list<R> >(str(es)); } return mklist<R>(hcx.accum, wcx.accum); } @@ -224,26 +214,26 @@ template<typename R> const failable<list<R>, std::string> apply(const list<list< /** * Evaluate an expression remotely, at the given URL. */ -const failable<value, std::string> evalExpr(const value& expr, const std::string& url, const CURLSession& ch) { +const failable<value> evalExpr(const value& expr, const string& url, const CURLSession& ch) { debug(url, "http::evalExpr::url"); debug(expr, "http::evalExpr::input"); // Convert expression to a JSON-RPC request json::JSONContext cx; - const failable<list<std::string>, std::string> jsreq = jsonRequest(1, car<value>(expr), cdr<value>(expr), cx); + const failable<list<string> > jsreq = json::jsonRequest(1, car<value>(expr), cdr<value>(expr), cx); if (!hasContent(jsreq)) - return mkfailure<value, std::string>(reason(jsreq)); + return mkfailure<value>(reason(jsreq)); // POST it to the URL - const list<std::string> h = mklist<std::string>("Content-Type: application/json-rpc"); - const failable<list<list<std::string> >, std::string> res = apply<list<std::string> >(mklist<list<std::string> >(h, content(jsreq)), rcons<std::string>, list<std::string>(), url, "POST", ch); + const list<string> h = mklist<string>("Content-Type: application/json-rpc"); + const failable<list<list<string> > > res = apply<list<string> >(mklist<list<string> >(h, content(jsreq)), rcons<string>, list<string>(), url, "POST", ch); if (!hasContent(res)) - return mkfailure<value, std::string>(reason(res)); + return mkfailure<value>(reason(res)); // Return result - failable<list<value>, std::string> jsres = json::readJSON(cadr<list<std::string> >(content(res)), cx); + failable<list<value> > jsres = json::readJSON(cadr<list<string> >(content(res)), cx); if (!hasContent(jsres)) - return mkfailure<value, std::string>(reason(jsres)); + return mkfailure<value>(reason(jsres)); const list<value> val = elementsToValues(content(jsres)); const value rval(cadr<value>(cadr<value>(val))); @@ -254,72 +244,88 @@ const failable<value, std::string> evalExpr(const value& expr, const std::string /** * Find and return a header. */ -const failable<std::string, std::string> header(const std::string& prefix, const list<std::string>& h) { +const failable<string> header(const char* prefix, const list<string>& h) { if (isNil(h)) - return mkfailure<std::string, std::string>(std::string("Couldn't find header: ") + prefix); - const std::string s = car(h); - if (s.find(prefix) != 0) + return mkfailure<string>(string("Couldn't find header: ") + prefix); + const string s = car(h); + if (find(s, prefix) != 0) return header(prefix, cdr(h)); - const std::string l(s.substr(prefix.length())); - return l.substr(0, l.find_first_of("\r\n")); + const string l(substr(s, length(prefix))); + return substr(l, 0, find_first_of(l, "\r\n")); } /** * Find and return a location header. */ -const failable<std::string, std::string> location(const list<std::string>& h) { +const failable<string> location(const list<string>& h) { return header("Location: ", h); } /** * Convert a location to an entry id. */ -const failable<value, std::string> entryId(const failable<std::string, std::string> l) { +const failable<value> entryId(const failable<string> l) { if (!hasContent(l)) - return mkfailure<value, std::string>(reason(l)); - const std::string ls(content(l)); - return value(ls.substr(ls.find_last_of("/") + 1)); + return mkfailure<value>(reason(l)); + const string ls(content(l)); + return value(string(substr(ls, find_last(ls, '/') + 1))); } /** * Find and return a content-type header. */ -const failable<std::string, std::string> contentType(const list<std::string>& h) { +const failable<string> contentType(const list<string>& h) { return header("Content-Type: ", h); } /** * HTTP GET, return the resource at the given URL. */ -template<typename R> const failable<list<R>, std::string> get(const lambda<R(const std::string&, const R)>& reduce, const R& initial, const std::string& url, const CURLSession& ch) { +template<typename R> const failable<list<R> > get(const lambda<R(const string&, const R)>& reduce, const R& initial, const string& url, const CURLSession& ch) { debug(url, "http::get::url"); - const list<list<std::string> > req = mklist(list<std::string>(), list<std::string>()); + const list<list<string> > req = mklist(list<string>(), list<string>()); return apply(req, reduce, initial, url, "GET", ch); } /** * HTTP GET, return a list of values representing the resource at the given URL. */ -const failable<value, std::string> get(const std::string& url, const CURLSession& ch) { +const failable<value> getcontent(const string& url, const CURLSession& ch) { + debug(url, "http::get::url"); + + // Get the contents of the resource at the given URL + const failable<list<list<string> > > res = get<list<string>>(rcons<string>, list<string>(), url, ch); + if (!hasContent(res)) + return mkfailure<value>(reason(res)); + const list<string> ls(reverse(cadr(content(res)))); + + // Return the content as a list of values + const value val(mkvalues(ls)); + debug(val, "http::get::result"); + return val; +} + +/** + * HTTP GET, return a list of values representing the resource at the given URL. + */ +const failable<value> get(const string& url, const CURLSession& ch) { debug(url, "http::get::url"); // Get the contents of the resource at the given URL - const failable<list<list<std::string> >, std::string> res = get<list<std::string> >(rcons<std::string>, list<std::string>(), url, ch); + const failable<list<list<string> > > res = get<list<string> >(rcons<string>, list<string>(), url, ch); if (!hasContent(res)) - return mkfailure<value, std::string>(reason(res)); - const list<std::string> ls(reverse(cadr(content(res)))); + return mkfailure<value>(reason(res)); + const list<string> ls(reverse(cadr(content(res)))); - const std::string ct(content(contentType(car(content(res))))); + const string ct(content(contentType(car(content(res))))); if (ct == "application/atom+xml;type=entry") { const value val(atom::entryValue(content(atom::readEntry(ls)))); debug(val, "http::get::result"); return val; } - // Return the content as a string value - std::ostringstream os; - write(ls, os); - const value val(os.str()); + // Return the content as a list of values + const value val(mkvalues(ls)); debug(val, "http::get::result"); return val; } @@ -327,24 +333,24 @@ const failable<value, std::string> get(const std::string& url, const CURLSession /** * HTTP POST. */ -const failable<value, std::string> post(const value& val, const std::string& url, const CURLSession& ch) { +const failable<value> post(const value& val, const string& url, const CURLSession& ch) { // Convert value to an ATOM entry - const failable<list<std::string>, std::string> entry = atom::writeATOMEntry(atom::entryValuesToElements(val)); + const failable<list<string> > entry = atom::writeATOMEntry(atom::entryValuesToElements(val)); if (!hasContent(entry)) - return mkfailure<value, std::string>(reason(entry)); + return mkfailure<value>(reason(entry)); debug(url, "http::post::url"); debug(content(entry), "http::post::input"); // POST it to the URL - const list<std::string> h = mklist<std::string>("Content-Type: application/atom+xml"); - const list<list<std::string> > req = mklist<list<std::string> >(h, content(entry)); - const failable<list<list<std::string> >, std::string> res = apply<list<std::string> >(req, rcons<std::string>, list<std::string>(), url, "POST", ch); + const list<string> h = mklist<string>("Content-Type: application/atom+xml"); + const list<list<string> > req = mklist<list<string> >(h, content(entry)); + const failable<list<list<string> > > res = apply<list<string>>(req, rcons<string>, list<string>(), url, "POST", ch); if (!hasContent(res)) - return mkfailure<value, std::string>(reason(res)); + return mkfailure<value>(reason(res)); // Return the new entry id from the HTTP location header - const failable<value, std::string> eid(entryId(location(car(content(res))))); + const failable<value> eid(entryId(location(car(content(res))))); debug(eid, "http::post::result"); return eid; } @@ -352,21 +358,21 @@ const failable<value, std::string> post(const value& val, const std::string& url /** * HTTP PUT. */ -const failable<value, std::string> put(const value& val, const std::string& url, const CURLSession& ch) { +const failable<value> put(const value& val, const string& url, const CURLSession& ch) { // Convert value to an ATOM entry - const failable<list<std::string>, std::string> entry = atom::writeATOMEntry(atom::entryValuesToElements(val)); + const failable<list<string> > entry = atom::writeATOMEntry(atom::entryValuesToElements(val)); if (!hasContent(entry)) - return mkfailure<value, std::string>(reason(entry)); + return mkfailure<value>(reason(entry)); debug(url, "http::put::url"); debug(content(entry), "http::put::input"); // PUT it to the URL - const list<std::string> h = mklist<std::string>("Content-Type: application/atom+xml"); - const list<list<std::string> > req = mklist<list<std::string> >(h, content(entry)); - const failable<list<list<std::string> >, std::string> res = apply<list<std::string> >(req, rcons<std::string>, list<std::string>(), url, "PUT", ch); + const list<string> h = mklist<string>("Content-Type: application/atom+xml"); + const list<list<string> > req = mklist<list<string> >(h, content(entry)); + const failable<list<list<string> > > res = apply<list<string> >(req, rcons<string>, list<string>(), url, "PUT", ch); if (!hasContent(res)) - return mkfailure<value, std::string>(reason(res)); + return mkfailure<value>(reason(res)); debug(true, "http::put::result"); return value(true); @@ -375,13 +381,13 @@ const failable<value, std::string> put(const value& val, const std::string& url, /** * HTTP DELETE. */ -const failable<value, std::string> del(const std::string& url, const CURLSession& ch) { +const failable<value, string> del(const string& url, const CURLSession& ch) { debug(url, "http::delete::url"); - const list<list<std::string> > req = mklist(list<std::string>(), list<std::string>()); - const failable<list<list<std::string> >, std::string> res = apply<list<std::string> >(req, rcons<std::string>, list<std::string>(), url, "DELETE", ch); + const list<list<string> > req = mklist(list<string>(), list<string>()); + const failable<list<list<string> > > res = apply<list<string> >(req, rcons<string>, list<string>(), url, "DELETE", ch); if (!hasContent(res)) - return mkfailure<value, std::string>(reason(res)); + return mkfailure<value>(reason(res)); debug(true, "http::delete::result"); return value(true); @@ -391,18 +397,18 @@ const failable<value, std::string> del(const std::string& url, const CURLSession * HTTP client proxy function. */ struct proxy { - proxy(const std::string& url) : url(url) { + proxy(const string& url) : url(url) { } const value operator()(const list<value>& args) const { CURLSession cs; - failable<value, std::string> val = evalExpr(args, url, cs); + failable<value> val = evalExpr(args, url, cs); if (!hasContent(val)) return value(); return content(val); } - const std::string url; + const string url; }; } diff --git a/sca-cpp/trunk/modules/http/httpd.hpp b/sca-cpp/trunk/modules/http/httpd.hpp index 890fee8f01..e0c5d110c4 100644 --- a/sca-cpp/trunk/modules/http/httpd.hpp +++ b/sca-cpp/trunk/modules/http/httpd.hpp @@ -26,8 +26,8 @@ * HTTPD module implementation functions. */ -#include <string> -#include <iostream> +#include "string.hpp" +#include "stream.hpp" #include "apr_strings.h" #include "apr_fnmatch.h" @@ -60,9 +60,7 @@ namespace httpd { * Returns a server-scoped module configuration. */ template<typename C> void* makeServerConf(apr_pool_t *p, server_rec *s) { - C* c = new (apr_palloc(p, sizeof(C))) C(s); - apr_pool_cleanup_register(p, c, gc_pool_cleanupCallback<C>, apr_pool_cleanup_null) ; - return c; + return new (gc_new<C>(p)) C(s); } template<typename C> const C& serverConf(const request_rec* r, const module* mod) { @@ -78,9 +76,7 @@ template<typename C> C& serverConf(const cmd_parms *cmd, const module* mod) { * Returns a directory-scoped module configuration. */ template<typename C> void *makeDirConf(apr_pool_t *p, char *dirspec) { - C* c = new (apr_palloc(p, sizeof(C))) C(dirspec); - apr_pool_cleanup_register(p, c, gc_pool_cleanupCallback<C>, apr_pool_cleanup_null) ; - return c; + return new (gc_new<C>(p)) C(dirspec); } template<typename C> C& dirConf(const request_rec* r, const module* mod) { @@ -90,31 +86,25 @@ template<typename C> C& dirConf(const request_rec* r, const module* mod) { /** * Convert a path string to a list of values. */ -const list<std::string> pathTokens(const char* p) { +const list<string> pathTokens(const char* p) { if (p == NULL || p[0] == '\0') - return list<std::string>(); + return list<string>(); if (p[0] == '/') return tokenize("/", p + 1); return tokenize("/", p); } -const list<value> pathValues(const list<std::string>& l) { - if (isNil(l)) - return list<value>(); - return cons<value>(car(l), pathValues(cdr(l))); -} - -const list<value> path(const char* p) { - return pathValues(pathTokens(p)); +const list<value> pathValues(const char* p) { + return mkvalues(pathTokens(p)); } /** * Convert a path represented as a list of values to a string. */ -const std::string path(const list<value>& p) { +const string path(const list<value>& p) { if (isNil(p)) return ""; - return std::string("/") + std::string(car(p)) + path(cdr(p)); + return string("/") + car(p) + path(cdr(p)); } /** @@ -126,7 +116,7 @@ const char* optional(const char* s) { return s; } -const std::string contentType(const request_rec* r) { +const string contentType(const request_rec* r) { return optional(apr_table_get(r->headers_in, "Content-Type")); } @@ -136,24 +126,24 @@ const std::string contentType(const request_rec* r) { * Debug log. */ int debugHeader(unused void* r, const char* key, const char* value) { - std::cerr << " header key: " << key << ", value: " << value << std::endl; + cerr << " header key: " << key << ", value: " << value << endl; return 1; } -const bool debugRequest(request_rec* r, const std::string& msg) { - std::cerr << msg << ":" << std::endl; - std::cerr << " protocol: " << optional(r->protocol) << std::endl; - std::cerr << " method: " << optional(r->method) << std::endl; - std::cerr << " method number: " << r->method_number << std::endl; - std::cerr << " content type: " << contentType(r) << std::endl; - std::cerr << " content encoding: " << optional(r->content_encoding) << std::endl; +const bool debugRequest(request_rec* r, const string& msg) { + cerr << msg << ":" << endl; + cerr << " protocol: " << optional(r->protocol) << endl; + cerr << " method: " << optional(r->method) << endl; + cerr << " method number: " << r->method_number << endl; + cerr << " content type: " << contentType(r) << endl; + cerr << " content encoding: " << optional(r->content_encoding) << endl; apr_table_do(debugHeader, r, r->headers_in, NULL); - std::cerr << " unparsed uri: " << optional(r->unparsed_uri) << std::endl; - std::cerr << " uri: " << optional(r->uri) << std::endl; - std::cerr << " path info: " << optional(r->path_info) << std::endl; - std::cerr << " filename: " << optional(r->filename) << std::endl; - std::cerr << " uri tokens: " << pathTokens(r->uri) << std::endl; - std::cerr << " args: " << optional(r->args) << std::endl; + cerr << " unparsed uri: " << optional(r->unparsed_uri) << endl; + cerr << " uri: " << optional(r->uri) << endl; + cerr << " path info: " << optional(r->path_info) << endl; + cerr << " filename: " << optional(r->filename) << endl; + cerr << " uri tokens: " << pathTokens(r->uri) << endl; + cerr << " args: " << optional(r->args) << endl; return true; } @@ -177,16 +167,16 @@ const list<value> pathInfo(const list<value>& uri, const list<value>& path) { /** * Returns a list of key value pairs from the args in a query string. */ -const list<value> queryArg(const std::string& s) { - const list<std::string> t = tokenize("=", s); - return mklist<value>(car(t).c_str(), cadr(t)); +const list<value> queryArg(const string& s) { + const list<string> t = tokenize("=", s); + return mklist<value>(c_str(car(t)), cadr(t)); } const list<list<value> > queryArgs(const request_rec* r) { const char* a = r->args; if (a == NULL) return list<list<value> >(); - return map<std::string, list<value>>(queryArg, tokenize("&", a)); + return map<string, list<value>>(queryArg, tokenize("&", a)); } /** @@ -229,50 +219,49 @@ const int setupReadPolicy(request_rec* r) { /** * Read the content of a POST or PUT. */ -const list<std::string> read(request_rec* r) { - char b[2048]; - const int n = ap_get_client_block(r, b, 2048); +const list<string> read(request_rec* r) { + char b[1024]; + const int n = ap_get_client_block(r, b, sizeof(b)); if (n <= 0) - return list<std::string>(); - return cons(std::string(b, n), read(r)); + return list<string>(); + return cons(string(b, n), read(r)); } /** * Convert a URI value to an absolute URL. */ const char* url(const value& v, request_rec* r) { - std::string u = r->uri; - u.append("/"); - u.append(v); - return ap_construct_url(r->pool, u.c_str(), r); + const string u = string(r->uri) + "/" + v; + return ap_construct_url(r->pool, c_str(u), r); } /** * Write an HTTP result. */ -const failable<int, std::string> writeResult(const failable<list<std::string>, std::string>& ls, const std::string& ct, request_rec* r) { +const failable<int> writeResult(const failable<list<string> >& ls, const string& ct, request_rec* r) { if (!hasContent(ls)) - return mkfailure<int, std::string>(reason(ls)); - std::ostringstream os; + return mkfailure<int>(reason(ls)); + ostringstream os; write(content(ls), os); - debug(os.str(), "httpd::result"); + const string ob(str(os)); + debug(ob, "httpd::result"); - const std::string etag(ap_md5(r->pool, (const unsigned char*)std::string(os.str()).c_str())); + const string etag(ap_md5(r->pool, (const unsigned char*)c_str(ob))); const char* match = apr_table_get(r->headers_in, "If-None-Match"); - apr_table_setn(r->headers_out, "ETag", apr_pstrdup(r->pool, etag.c_str())); + apr_table_setn(r->headers_out, "ETag", apr_pstrdup(r->pool, c_str(etag))); if (match != NULL && etag == match) { r->status = HTTP_NOT_MODIFIED; return OK; } - ap_set_content_type(r, apr_pstrdup(r->pool, ct.c_str())); - ap_rputs(std::string(os.str()).c_str(), r); + ap_set_content_type(r, apr_pstrdup(r->pool, c_str(ct))); + ap_rputs(c_str(ob), r); return OK; } /** * Report request execution status. */ -const int reportStatus(const failable<int, std::string>& rc) { +const int reportStatus(const failable<int>& rc) { if (!hasContent(rc)) return HTTP_INTERNAL_SERVER_ERROR; return content(rc); diff --git a/sca-cpp/trunk/modules/json/json-test.cpp b/sca-cpp/trunk/modules/json/json-test.cpp index 4d1bbffd5a..b4a6ba8746 100644 --- a/sca-cpp/trunk/modules/json/json-test.cpp +++ b/sca-cpp/trunk/modules/json/json-test.cpp @@ -24,10 +24,8 @@ */ #include <assert.h> -#include <iostream> -#include <sstream> -#include <string> -#include "slist.hpp" +#include "stream.hpp" +#include "string.hpp" #include "json.hpp" namespace tuscany { @@ -35,15 +33,15 @@ namespace json { bool testJSEval() { JSONContext cx; - const std::string script("(function testJSON(n){ return JSON.parse(JSON.stringify(n)) })(5)"); + const string script("(function testJSON(n){ return JSON.parse(JSON.stringify(n)) })(5)"); jsval rval; - assert(JS_EvaluateScript(cx, cx.getGlobal(), script.c_str(), script.length(), "testJSON.js", 1, &rval)); - const std::string r(JS_GetStringBytes(JS_ValueToString(cx, rval))); + assert(JS_EvaluateScript(cx, cx.getGlobal(), c_str(script), length(script), "testJSON.js", 1, &rval)); + const string r(JS_GetStringBytes(JS_ValueToString(cx, rval))); assert(r == "5"); return true; } -std::ostringstream* jsonWriter(const std::string& s, std::ostringstream* os) { +ostream* jsonWriter(const string& s, ostream* os) { (*os) << s; return os; } @@ -52,30 +50,30 @@ bool testJSON() { const JSONContext cx; { - const list<value> ad = mklist<value>(mklist<value>(attribute, "city", std::string("san francisco")), mklist<value>(attribute, "state", std::string("ca"))); - const list<value> ac = mklist<value>(mklist<value>(element, "id", std::string("1234")), mklist<value>(attribute, "balance", 1000)); - const list<value> cr = mklist<value>(mklist<value> (attribute, "name", std::string("jdoe")), cons<value>(element, cons<value>("address", ad)), cons<value>(element, cons<value>("account", ac))); + const list<value> ad = mklist<value>(mklist<value>(attribute, "city", string("san francisco")), mklist<value>(attribute, "state", string("ca"))); + const list<value> ac = mklist<value>(mklist<value>(element, "id", string("1234")), mklist<value>(attribute, "balance", 1000)); + const list<value> cr = mklist<value>(mklist<value> (attribute, "name", string("jdoe")), cons<value>(element, cons<value>("address", ad)), cons<value>(element, cons<value>("account", ac))); const list<value> c = mklist<value>(cons<value>(element, cons<value>("customer", cr))); - std::ostringstream os; - writeJSON<std::ostringstream*>(jsonWriter, &os, c, cx); - assert(os.str() == "{\"customer\":{\"name\":\"jdoe\",\"address\":{\"city\":\"san francisco\",\"state\":\"ca\"},\"account\":{\"id\":\"1234\",\"balance\":1000}}}"); + ostringstream os; + writeJSON<ostream*>(jsonWriter, &os, c, cx); + assert(str(os) == "{\"customer\":{\"name\":\"jdoe\",\"address\":{\"city\":\"san francisco\",\"state\":\"ca\"},\"account\":{\"id\":\"1234\",\"balance\":1000}}}"); } { - const list<value> phones = mklist<value> (std::string("408-1234"), std::string("650-1234")); - const list<value> l = mklist<value> (mklist<value> (element, "phones", phones), mklist<value> (element, "lastName", std::string("test\ttab")), mklist<value> (element, "firstName", std::string("test1"))); + const list<value> phones = mklist<value> (string("408-1234"), string("650-1234")); + const list<value> l = mklist<value> (mklist<value> (element, "phones", phones), mklist<value> (element, "lastName", string("test\ttab")), mklist<value> (element, "firstName", string("test1"))); - std::ostringstream os; - writeJSON<std::ostringstream*>(jsonWriter, &os, l, cx); - assert(os.str() == "{\"phones\":[\"408-1234\",\"650-1234\"],\"lastName\":\"test\\u0009tab\",\"firstName\":\"test1\"}"); + ostringstream os; + writeJSON<ostream*>(jsonWriter, &os, l, cx); + assert(str(os) == "{\"phones\":[\"408-1234\",\"650-1234\"],\"lastName\":\"test\\u0009tab\",\"firstName\":\"test1\"}"); - std::istringstream is(os.str()); - const list<std::string> il = streamList(is); + istringstream is(str(os)); + const list<string> il = streamList(is); const list<value> r = content(readJSON(il, cx)); assert(r == l); - std::ostringstream wos; + ostringstream wos; write(content(writeJSON(r, cx)), wos); - assert(wos.str() == os.str()); + assert(str(wos) == str(os)); } return true; } @@ -83,45 +81,45 @@ bool testJSON() { bool testJSONRPC() { JSONContext cx; { - const std::string lm("{\"id\": 1, \"method\": \"system.listMethods\", \"params\": []}"); + const string lm("{\"id\": 1, \"method\": \"system.listMethods\", \"params\": []}"); const list<value> e = content(readJSON(mklist(lm), cx)); const list<value> v = elementsToValues(e); assert(assoc<value>("id", v) == mklist<value>("id", 1)); - assert(assoc<value>("method", v) == mklist<value>("method", std::string("system.listMethods"))); + assert(assoc<value>("method", v) == mklist<value>("method", string("system.listMethods"))); assert(assoc<value>("params", v) == mklist<value>("params", list<value>())); } { - const std::string i("{\"id\":3,\"result\":[{\"price\":\"$2.99\",\"name\":\"Apple\"},{\"price\":\"$3.55\",\"name\":\"Orange\"},{\"price\":\"$1.55\",\"name\":\"Pear\"}]}"); + const string i("{\"id\":3,\"result\":[{\"price\":\"$2.99\",\"name\":\"Apple\"},{\"price\":\"$3.55\",\"name\":\"Orange\"},{\"price\":\"$1.55\",\"name\":\"Pear\"}]}"); const list<value> e = content(readJSON(mklist(i), cx)); - const std::string i2("{\"id\":3,\"result\":{\"0\":{\"price\":\"$2.99\",\"name\":\"Apple\"},\"1\":{\"price\":\"$3.55\",\"name\":\"Orange\"},\"2\":{\"price\":\"$1.55\",\"name\":\"Pear\"}}}"); + const string i2("{\"id\":3,\"result\":{\"0\":{\"price\":\"$2.99\",\"name\":\"Apple\"},\"1\":{\"price\":\"$3.55\",\"name\":\"Orange\"},\"2\":{\"price\":\"$1.55\",\"name\":\"Pear\"}}}"); const list<value> e2 = content(readJSON(mklist(i), cx)); assert(e == e2); } { - const std::string i("{\"id\":3,\"result\":[{\"price\":\"$2.99\",\"name\":\"Apple\"},{\"price\":\"$3.55\",\"name\":\"Orange\"},{\"price\":\"$1.55\",\"name\":\"Pear\"}]}"); + const string i("{\"id\":3,\"result\":[{\"price\":\"$2.99\",\"name\":\"Apple\"},{\"price\":\"$3.55\",\"name\":\"Orange\"},{\"price\":\"$1.55\",\"name\":\"Pear\"}]}"); const list<value> e = content(readJSON(mklist(i), cx)); - std::ostringstream os; + ostringstream os; write(content(writeJSON(e, cx)), os); - assert(os.str() == i); + assert(str(os) == i); const list<value> v = elementsToValues(e); const list<value> r = valuesToElements(v); assert(r == e); } { - const list<value> r = mklist<value>(mklist<value>("id", 1), mklist<value>("result", mklist<value>(std::string("Service.get"), std::string("Service.getTotal")))); + const list<value> r = mklist<value>(mklist<value>("id", 1), mklist<value>("result", mklist<value>(string("Service.get"), string("Service.getTotal")))); const list<value> e = valuesToElements(r); - std::ostringstream os; + ostringstream os; write(content(writeJSON(e, cx)), os); - assert(os.str() == "{\"id\":1,\"result\":[\"Service.get\",\"Service.getTotal\"]}"); + assert(str(os) == "{\"id\":1,\"result\":[\"Service.get\",\"Service.getTotal\"]}"); } { - const std::string f("{\"id\":1,\"result\":[\"Sample Feed\",\"123456789\",[\"Item\",\"111\",{\"javaClass\":\"services.Item\",\"name\":\"Apple\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":2.99}],[\"Item\",\"222\",{\"javaClass\":\"services.Item\",\"name\":\"Orange\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":3.55}],[\"Item\",\"333\",{\"javaClass\":\"services.Item\",\"name\":\"Pear\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":1.55}]]}"); + const string f("{\"id\":1,\"result\":[\"Sample Feed\",\"123456789\",[\"Item\",\"111\",{\"javaClass\":\"services.Item\",\"name\":\"Apple\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":2.99}],[\"Item\",\"222\",{\"javaClass\":\"services.Item\",\"name\":\"Orange\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":3.55}],[\"Item\",\"333\",{\"javaClass\":\"services.Item\",\"name\":\"Pear\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":1.55}]]}"); const list<value> r = content(readJSON(mklist(f), cx)); const list<value> v = elementsToValues(r); const list<value> e = valuesToElements(v); - std::ostringstream os; + ostringstream os; write(content(writeJSON(e, cx)), os); - assert(os.str() == f); + assert(str(os) == f); } return true; } @@ -130,13 +128,13 @@ bool testJSONRPC() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::json::testJSEval(); tuscany::json::testJSON(); tuscany::json::testJSONRPC(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/json/json.hpp b/sca-cpp/trunk/modules/json/json.hpp index 6ce4e3a9a1..9124c5143c 100644 --- a/sca-cpp/trunk/modules/json/json.hpp +++ b/sca-cpp/trunk/modules/json/json.hpp @@ -28,7 +28,7 @@ #define XP_UNIX #include <jsapi.h> -#include <string> +#include "string.hpp" #include "list.hpp" #include "value.hpp" #include "element.hpp" @@ -41,8 +41,8 @@ namespace json { * Report JSON errors. */ void reportError(unused JSContext *cx, const char *message, JSErrorReport *report) { - std::cerr << (const char*)(report->filename? report->filename : "<no filename>") << ":" - << (unsigned int)report->lineno << ":" << message << std::endl; + cerr << (const char*)(report->filename? report->filename : "<no filename>") << ":" + << (int)report->lineno << ":" << message << endl; } /** @@ -168,7 +168,7 @@ const list<value> jsPropertiesToValues(const list<value>& propertiesSoFar, JSObj const value jsValToValue(const jsval& jsv, const JSONContext& cx) { switch(JS_TypeOfValue(cx, jsv)) { case JSTYPE_STRING: { - return value(std::string(JS_GetStringBytes(JSVAL_TO_STRING(jsv)))); + return value(string(JS_GetStringBytes(JSVAL_TO_STRING(jsv)))); } case JSTYPE_BOOLEAN: { return value((bool)JSVAL_TO_BOOLEAN(jsv)); @@ -195,30 +195,30 @@ const value jsValToValue(const jsval& jsv, const JSONContext& cx) { /** * Consumes JSON strings and populates a JS object. */ -failable<bool, std::string> consume(JSONParser* parser, const list<std::string>& ilist, const JSONContext& cx) { +failable<bool> consume(JSONParser* parser, const list<string>& ilist, const JSONContext& cx) { if (isNil(ilist)) return true; - JSString* jstr = JS_NewStringCopyZ(cx, car(ilist).c_str()); + JSString* jstr = JS_NewStringCopyZ(cx, c_str(car(ilist))); if(!JS_ConsumeJSONText(cx, parser, JS_GetStringChars(jstr), JS_GetStringLength(jstr))) - return mkfailure<bool, std::string>("JS_ConsumeJSONText failed"); + return mkfailure<bool>("JS_ConsumeJSONText failed"); return consume(parser, cdr(ilist), cx); } /** * Convert a list of strings representing a JSON document to a list of values. */ -const failable<list<value>, std::string> readJSON(const list<std::string>& ilist, const JSONContext& cx) { +const failable<list<value> > readJSON(const list<string>& ilist, const JSONContext& cx) { jsval val; JSONParser* parser = JS_BeginJSONParse(cx, &val); if(parser == NULL) - return mkfailure<list<value>, std::string>("JS_BeginJSONParse failed"); + return mkfailure<list<value> >("JS_BeginJSONParse failed"); - const failable<bool, std::string> consumed = consume(parser, ilist, cx); + const failable<bool> consumed = consume(parser, ilist, cx); if(!JS_FinishJSONParse(cx, parser, JSVAL_NULL)) - return mkfailure<list<value>, std::string>("JS_FinishJSONParse failed"); + return mkfailure<list<value> >("JS_FinishJSONParse failed"); if(!hasContent(consumed)) - return mkfailure<list<value>, std::string>(reason(consumed)); + return mkfailure<list<value> >(reason(consumed)); return list<value>(jsValToValue(val, cx)); } @@ -261,7 +261,7 @@ JSObject* valuesToJSProperties(JSObject* o, const list<value>& l, const JSONCont return o; const list<value> p = car(l); jsval pv = valueToJSVal(caddr(p), cx); - JS_SetProperty(cx, o, ((std::string)cadr(p)).c_str(), &pv); + JS_SetProperty(cx, o, c_str((string)cadr(p)), &pv); return valuesToJSProperties(o, cdr(l), cx); } @@ -272,7 +272,7 @@ const jsval valueToJSVal(const value& val, const JSONContext& cx) { switch(type(val)) { case value::String: case value::Symbol: { - return STRING_TO_JSVAL(JS_NewStringCopyZ(cx, ((std::string)val).c_str())); + return STRING_TO_JSVAL(JS_NewStringCopyZ(cx, c_str((string)val))); } case value::Bool: { return BOOLEAN_TO_JSVAL((bool)val); @@ -291,7 +291,7 @@ const jsval valueToJSVal(const value& val, const JSONContext& cx) { } } -const failable<bool, std::string> writeList(const list<value>& l, JSObject* o, const JSONContext& cx) { +const failable<bool> writeList(const list<value>& l, JSObject* o, const JSONContext& cx) { if (isNil(l)) return true; @@ -300,24 +300,24 @@ const failable<bool, std::string> writeList(const list<value>& l, JSObject* o, c if (isTaggedList(token, attribute)) { jsval pv = valueToJSVal(attributeValue(token), cx); - JS_SetProperty(cx, o, std::string(attributeName(token)).c_str(), &pv); + JS_SetProperty(cx, o, c_str(string(attributeName(token))), &pv); } else if (isTaggedList(token, element)) { // Write the value of an element if (elementHasValue(token)) { jsval pv = valueToJSVal(elementValue(token), cx); - JS_SetProperty(cx, o, std::string(elementName(token)).c_str(), &pv); + JS_SetProperty(cx, o, c_str(string(elementName(token))), &pv); } else { // Write a parent element JSObject* child = JS_NewObject(cx, NULL, NULL, NULL); jsval pv = OBJECT_TO_JSVAL(child); - JS_SetProperty(cx, o, std::string(elementName(token)).c_str(), &pv); + JS_SetProperty(cx, o, c_str(string(elementName(token))), &pv); // Write its children - const failable<bool, std::string> w = writeList(elementChildren(token), child, cx); + const failable<bool> w = writeList(elementChildren(token), child, cx); if (!hasContent(w)) return w; } @@ -332,10 +332,10 @@ const failable<bool, std::string> writeList(const list<value>& l, JSObject* o, c */ template<typename R> class WriteContext { public: - WriteContext(const lambda<R(const std::string&, const R)>& reduce, const R& accum, const JSONContext& cx) : cx(cx), reduce(reduce), accum(accum) { + WriteContext(const lambda<R(const string&, const R)>& reduce, const R& accum, const JSONContext& cx) : cx(cx), reduce(reduce), accum(accum) { } const JSONContext& cx; - const lambda<R(const std::string&, const R)> reduce; + const lambda<R(const string&, const R)> reduce; R accum; }; @@ -345,40 +345,40 @@ public: template<typename R> JSBool writeCallback(const jschar *buf, uint32 len, void *data) { WriteContext<R>& wcx = *(static_cast<WriteContext<R>*> (data)); JSString* jstr = JS_NewUCStringCopyN(wcx.cx, buf, len); - wcx.accum = wcx.reduce(std::string(JS_GetStringBytes(jstr), JS_GetStringLength(jstr)), wcx.accum); + wcx.accum = wcx.reduce(string(JS_GetStringBytes(jstr), JS_GetStringLength(jstr)), wcx.accum); return JS_TRUE; } /** * Convert a list of values to a JSON document. */ -template<typename R> const failable<R, std::string> writeJSON(const lambda<R(const std::string&, const R)>& reduce, const R& initial, const list<value>& l, const JSONContext& cx) { +template<typename R> const failable<R> writeJSON(const lambda<R(const string&, const R)>& reduce, const R& initial, const list<value>& l, const JSONContext& cx) { JSObject* o = JS_NewObject(cx, NULL, NULL, NULL); jsval val = OBJECT_TO_JSVAL(o); - const failable<bool, std::string> w = writeList(l, o, cx); + const failable<bool> w = writeList(l, o, cx); if (!hasContent(w)) - return mkfailure<R, std::string>(reason(w)); + return mkfailure<R>(reason(w)); WriteContext<R> wcx(reduce, initial, cx); if (!JS_Stringify(cx, &val, NULL, JSVAL_NULL, writeCallback<R>, &wcx)) - return mkfailure<R, std::string>("JS_Stringify failed"); + return mkfailure<R>("JS_Stringify failed"); return wcx.accum; } /** * Convert a list of values to a list of strings representing a JSON document. */ -const failable<list<std::string>, std::string> writeJSON(const list<value>& l, const JSONContext& cx) { - const failable<list<std::string>, std::string> ls = writeJSON<list<std::string> >(rcons<std::string>, list<std::string>(), l, cx); +const failable<list<string> > writeJSON(const list<value>& l, const JSONContext& cx) { + const failable<list<string> > ls = writeJSON<list<string>>(rcons<string>, list<string>(), l, cx); if (!hasContent(ls)) return ls; - return reverse(list<std::string>(content(ls))); + return reverse(list<string>(content(ls))); } /** * Convert a function + params to a JSON request. */ -const failable<list<std::string>, std::string> jsonRequest(const value& id, const value& func, const value& params, json::JSONContext& cx) { +const failable<list<string> > jsonRequest(const value& id, const value& func, const value& params, json::JSONContext& cx) { const list<value> r = mklist<value>(mklist<value>("id", id), mklist<value>("method", func), mklist<value>("params", params)); return writeJSON(valuesToElements(r), cx); } @@ -386,7 +386,7 @@ const failable<list<std::string>, std::string> jsonRequest(const value& id, cons /** * Convert a value to a JSON result. */ -const failable<list<std::string>, std::string> jsonResult(const value& id, const value& val, JSONContext& cx) { +const failable<list<string> > jsonResult(const value& id, const value& val, JSONContext& cx) { return writeJSON(valuesToElements(mklist<value>(mklist<value>("id", id), mklist<value>("result", val))), cx); } diff --git a/sca-cpp/trunk/modules/scdl/scdl-test.cpp b/sca-cpp/trunk/modules/scdl/scdl-test.cpp index 582d1ee073..d6034d1e2f 100644 --- a/sca-cpp/trunk/modules/scdl/scdl-test.cpp +++ b/sca-cpp/trunk/modules/scdl/scdl-test.cpp @@ -24,12 +24,9 @@ */ #include <assert.h> -#include <iostream> -#include <sstream> -#include <fstream> -#include <string> +#include "stream.hpp" +#include "string.hpp" #include "list.hpp" -#include "slist.hpp" #include "tree.hpp" #include "scdl.hpp" @@ -37,24 +34,24 @@ namespace tuscany { namespace scdl { bool testComposite() { - std::ifstream is("test.composite"); + ifstream is("test.composite"); const list<value> c = readXML(streamList(is)); return true; } bool testComponents() { - std::ifstream is("test.composite"); + ifstream is("test.composite"); const list<value> c = components(readXML(streamList(is))); assert(length(c) == 4); const value store = car(c); - assert(name(store) == std::string("Store")); + assert(name(store) == string("Store")); const value impl = implementation(store); - assert(uri(impl) == std::string("store.html")); + assert(uri(impl) == string("store.html")); assert(implementationType(impl) == "t:implementation.widget"); - const value catalog = named(std::string("Catalog"), c); - assert(name(catalog) == std::string("Catalog")); + const value catalog = named(string("Catalog"), c); + assert(name(catalog) == string("Catalog")); const list<value> t = mkbtree(sort(nameToElementAssoc(c))); assert(assoctree<value>("Catalog", t) == mklist<value>("Catalog" , cadr(c))); @@ -62,30 +59,30 @@ bool testComponents() { } bool testServices() { - std::ifstream is("test.composite"); + ifstream is("test.composite"); const list<value> c = components(readXML(streamList(is))); const value store = car(c); assert(length(services(store)) == 1); const value widget = car(services(store)); - assert(name(widget) == std::string("Widget")); + assert(name(widget) == string("Widget")); assert(length(bindings(widget)) == 1); const value binding = car(bindings(widget)); - assert(uri(binding) == std::string("/store")); + assert(uri(binding) == string("/store")); assert(bindingType(binding) == "t:binding.http"); return true; } bool testReferences() { - std::ifstream is("test.composite"); + ifstream is("test.composite"); const list<value> c = components(readXML(streamList(is))); const value store = car(c); assert(length(references(store)) == 3); const value catalog = car(references(store)); - assert(name(catalog) == std::string("catalog")); - assert(target(catalog) == std::string("Catalog")); + assert(name(catalog) == string("catalog")); + assert(target(catalog) == string("Catalog")); assert(length(bindings(catalog)) == 1); const value binding = car(bindings(catalog)); @@ -93,19 +90,19 @@ bool testReferences() { assert(bindingType(binding) == "t:binding.jsonrpc"); const list<value> t = mkbtree(sort(referenceToTargetAssoc(references(store)))); - assert(assoctree<value>("shoppingCart", t) == mklist<value>(std::string("shoppingCart"), std::string("ShoppingCart/Cart"))); + assert(assoctree<value>("shoppingCart", t) == mklist<value>(string("shoppingCart"), string("ShoppingCart/Cart"))); return true; } bool testProperties() { - std::ifstream is("test.composite"); + ifstream is("test.composite"); const list<value> c = components(readXML(streamList(is))); - const value catalog = named(std::string("Catalog"), c); + const value catalog = named(string("Catalog"), c); assert(length(properties(catalog)) == 1); const value currencyCode = car(properties(catalog)); - assert(name(currencyCode) == std::string("currencyCode")); - assert(propertyValue(currencyCode) == std::string("USD")); + assert(name(currencyCode) == string("currencyCode")); + assert(propertyValue(currencyCode) == string("USD")); return true; } @@ -113,7 +110,7 @@ bool testProperties() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::scdl::testComposite(); tuscany::scdl::testComponents(); @@ -121,7 +118,7 @@ int main() { tuscany::scdl::testReferences(); tuscany::scdl::testProperties(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/scdl/scdl.hpp b/sca-cpp/trunk/modules/scdl/scdl.hpp index 9d4bf38b50..531144e219 100644 --- a/sca-cpp/trunk/modules/scdl/scdl.hpp +++ b/sca-cpp/trunk/modules/scdl/scdl.hpp @@ -26,7 +26,7 @@ * SCDL read functions. */ -#include <string> +#include "string.hpp" #include "list.hpp" #include "value.hpp" #include "monad.hpp" @@ -85,7 +85,7 @@ const value named(const value& name, const value& l) { * Returns the implementation of a component. */ const bool filterImplementation(const value& v) { - return isElement(v) && std::string(cadr<value>(v)).find("implementation.") != std::string::npos; + return isElement(v) && contains(string(cadr<value>(v)), "implementation."); } const value implementation(const value& l) { @@ -137,7 +137,7 @@ const list<value> referenceToTargetAssoc(const list<value>& r) { * Returns a list of bindings in a service or reference. */ const bool filterBinding(const value& v) { - return isElement(v) && std::string(cadr<value>(v)).find("binding.") != std::string::npos; + return isElement(v) && contains(string(cadr<value>(v)), "binding."); } const list<value> bindings(const value& l) { diff --git a/sca-cpp/trunk/modules/server/client-test.cpp b/sca-cpp/trunk/modules/server/client-test.cpp index 496d67f59c..2728cfc6d5 100644 --- a/sca-cpp/trunk/modules/server/client-test.cpp +++ b/sca-cpp/trunk/modules/server/client-test.cpp @@ -23,11 +23,12 @@ * Test HTTP client functions. */ +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> #include <assert.h> -#include <iostream> -#include <sstream> -#include <string> -#include "slist.hpp" +#include "stream.hpp" +#include "string.hpp" #include "parallel.hpp" #include "perf.hpp" #include "../http/curl.hpp" @@ -35,11 +36,7 @@ namespace tuscany { namespace server { -const bool contains(const std::string& str, const std::string& pattern) { - return str.find(pattern) != str.npos; -} - -std::ostringstream* curlWriter(const std::string& s, std::ostringstream* os) { +ostream* curlWriter(const string& s, ostream* os) { (*os) << s; return os; } @@ -47,16 +44,16 @@ std::ostringstream* curlWriter(const std::string& s, std::ostringstream* os) { const bool testGet() { http::CURLSession ch; { - std::ostringstream os; - const failable<list<std::ostringstream*>, std::string> r = http::get<std::ostringstream*>(curlWriter, &os, "http://localhost:8090", ch); + ostringstream os; + const failable<list<ostream*> > r = http::get<ostream*>(curlWriter, &os, "http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(os.str(), "HTTP/1.1 200 OK")); - assert(contains(os.str(), "It works")); + assert(contains(str(os), "HTTP/1.1 200 OK")); + assert(contains(str(os), "It works")); } { - const failable<value, std::string> r = http::get("http://localhost:8090", ch); + const failable<value> r = http::getcontent("http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(content(r), "It works")); + assert(contains(car(reverse(list<value>(content(r)))), "It works")); } return true; } @@ -66,9 +63,9 @@ struct getLoop { getLoop(http::CURLSession& ch) : ch(ch) { } const bool operator()() const { - const failable<value, std::string> r = get("http://localhost:8090", ch); + const failable<value> r = http::getcontent("http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(content(r), "It works")); + assert(contains(car(reverse(list<value>(content(r)))), "It works")); return true; } }; @@ -76,14 +73,14 @@ struct getLoop { const bool testGetPerf() { http::CURLSession ch; const lambda<bool()> gl = getLoop(ch); - std::cout << "Static GET test " << time(gl, 5, 200) << " ms" << std::endl; + cout << "Static GET test " << time(gl, 5, 200) << " ms" << endl; return true; } const bool testEval() { http::CURLSession ch; - const value val = content(http::evalExpr(mklist<value>(std::string("echo"), std::string("Hello")), "http://localhost:8090/test", ch)); - assert(val == std::string("Hello")); + const value val = content(http::evalExpr(mklist<value>(string("echo"), string("Hello")), "http://localhost:8090/test", ch)); + assert(val == string("Hello")); return true; } @@ -92,13 +89,13 @@ struct evalLoop { evalLoop(http::CURLSession& ch) : ch(ch) { } const bool operator()() const { - const value val = content(http::evalExpr(mklist<value>(std::string("echo"), std::string("Hello")), "http://localhost:8090/test", ch)); - assert(val == std::string("Hello")); + const value val = content(http::evalExpr(mklist<value>(string("echo"), string("Hello")), "http://localhost:8090/test", ch)); + assert(val == string("Hello")); return true; } }; -const value blob(std::string(3000, 'A')); +const value blob(string(3000, 'A')); const list<value> blobs = mklist(blob, blob, blob, blob, blob); struct blobEvalLoop { @@ -106,7 +103,7 @@ struct blobEvalLoop { blobEvalLoop(http::CURLSession& ch) : ch(ch) { } const bool operator()() const { - const value val = content(http::evalExpr(mklist<value>(std::string("echo"), blobs), "http://localhost:8090/test", ch)); + const value val = content(http::evalExpr(mklist<value>(string("echo"), blobs), "http://localhost:8090/test", ch)); assert(val == blobs); return true; } @@ -115,19 +112,19 @@ struct blobEvalLoop { const bool testEvalPerf() { http::CURLSession ch; const lambda<bool()> el = evalLoop(ch); - std::cout << "JSON-RPC eval echo test " << time(el, 5, 200) << " ms" << std::endl; + cout << "JSON-RPC eval echo test " << time(el, 5, 200) << " ms" << endl; const lambda<bool()> bel = blobEvalLoop(ch); - std::cout << "JSON-RPC eval blob test " << time(bel, 5, 200) << " ms" << std::endl; + cout << "JSON-RPC eval blob test " << time(bel, 5, 200) << " ms" << endl; return true; } bool testPost() { const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$2.99")); - const list<value> a = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const list<value> a = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); http::CURLSession ch; - const failable<value, std::string> id = http::post(a, "http://localhost:8090/test", ch); + const failable<value> id = http::post(a, "http://localhost:8090/test", ch); assert(hasContent(id)); return true; } @@ -138,7 +135,7 @@ struct postLoop { postLoop(const value& val, http::CURLSession& ch) : val(val), ch(ch) { } const bool operator()() const { - const failable<value, std::string> id = http::post(val, "http://localhost:8090/test", ch); + const failable<value> id = http::post(val, "http://localhost:8090/test", ch); assert(hasContent(id)); return true; } @@ -148,28 +145,30 @@ const bool testPostPerf() { http::CURLSession ch; { const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$2.99")); - const list<value> val = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const list<value> val = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); const lambda<bool()> pl = postLoop(val, ch); - std::cout << "ATOMPub POST small test " << time(pl, 5, 200) << " ms" << std::endl; + cout << "ATOMPub POST small test " << time(pl, 5, 200) << " ms" << endl; } { const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "blob1" << blob) - << (list<value>() << "blob2" << blob) - << (list<value>() << "blob3" << blob) - << (list<value>() << "blob4" << blob) - << (list<value>() << "blob5" << blob) - << (list<value>() << "price" << std::string("$2.99")); - const list<value> val = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "blob1" + blob) + + (list<value>() + "blob2" + blob) + + (list<value>() + "blob3" + blob) + + (list<value>() + "blob4" + blob) + + (list<value>() + "blob5" + blob) + + (list<value>() + "price" + string("$2.99")); + const list<value> val = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); const lambda<bool()> pl = postLoop(val, ch); - std::cout << "ATOMPub POST blob test " << time(pl, 5, 200) << " ms" << std::endl; + cout << "ATOMPub POST blob test " << time(pl, 5, 200) << " ms" << endl; } return true; } +#ifdef _REENTRANT + const bool postThread(const int count, const value& val) { http::CURLSession ch; const lambda<bool()> pl = postLoop(val, ch); @@ -194,7 +193,7 @@ struct postThreadLoop { const lambda<bool()> l; const int threads; const gc_ptr<worker> w; - postThreadLoop(const lambda<bool()>& l, const int threads) : l(l), threads(threads), w(new worker(threads)) { + postThreadLoop(const lambda<bool()>& l, const int threads) : l(l), threads(threads), w(new (gc_new<worker>()) worker(threads)) { } const bool operator()() const { list<future<bool> > r = startPost(*w, threads, l); @@ -208,23 +207,83 @@ const bool testPostThreadPerf() { const int threads = 10; const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$2.99")); - const value val = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const value val = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); const lambda<bool()> pl= curry(lambda<bool(const int, const value)>(postThread), count, val); const lambda<bool()> ptl = postThreadLoop(pl, threads); double t = time(ptl, 0, 1) / (threads * count); - std::cout << "ATOMPub POST thread test " << t << " ms" << std::endl; + cout << "ATOMPub POST thread test " << t << " ms" << endl; return true; } +#else + +const bool postProc(const int count, const value& val) { + http::CURLSession ch; + const lambda<bool()> pl = postLoop(val, ch); + time(pl, 0, count); + return true; +} + +const list<pid_t> startPost(const int procs, const lambda<bool()>& l) { + if (procs == 0) + return list<pid_t>(); + pid_t pid = fork(); + if (pid == 0) { + assert(l() == true); + exit(0); + } + return cons(pid, startPost(procs - 1, l)); +} + +const bool checkPost(const list<pid_t>& r) { + if (isNil(r)) + return true; + int status; + waitpid(car(r), &status, 0); + assert(status == 0); + return checkPost(cdr(r)); +} + +struct postForkLoop { + const lambda<bool()> l; + const int procs; + postForkLoop(const lambda<bool()>& l, const int procs) : l(l), procs(procs) { + } + const bool operator()() const { + list<pid_t> r = startPost(procs, l); + checkPost(r); + return true; + } +}; + +const bool testPostForkPerf() { + const int count = 50; + const int procs = 10; + + const list<value> i = list<value>() + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const value val = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + const lambda<bool()> pl= curry(lambda<bool(const int, const value)>(postProc), count, val); + const lambda<bool()> ptl = postForkLoop(pl, procs); + double t = time(ptl, 0, 1) / (procs * count); + cout << "ATOMPub POST fork test " << t << " ms" << endl; + + return true; +} + +#endif + const bool testPut() { const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$2.99")); - const list<value> a = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const list<value> a = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); http::CURLSession ch; value rc = content(http::put(a, "http://localhost:8090/test/111", ch)); assert(rc == value(true)); @@ -240,8 +299,8 @@ const bool testDel() { const bool testEvalCpp() { http::CURLSession ch; - const value val = content(http::evalExpr(mklist<value>(std::string("hello"), std::string("world")), "http://localhost:8090/cpp", ch)); - assert(val == std::string("hello world")); + const value val = content(http::evalExpr(mklist<value>(string("hello"), string("world")), "http://localhost:8090/cpp", ch)); + assert(val == string("hello world")); return true; } @@ -250,8 +309,8 @@ struct evalCppLoop { evalCppLoop(http::CURLSession& ch) : ch(ch) { } const bool operator()() const { - const value val = content(http::evalExpr(mklist<value>(std::string("hello"), std::string("world")), "http://localhost:8090/cpp", ch)); - assert(val == std::string("hello world")); + const value val = content(http::evalExpr(mklist<value>(string("hello"), string("world")), "http://localhost:8090/cpp", ch)); + assert(val == string("hello world")); return true; } }; @@ -259,7 +318,7 @@ struct evalCppLoop { const bool testEvalCppPerf() { http::CURLSession ch; const lambda<bool()> el = evalCppLoop(ch); - std::cout << "JSON-RPC C++ eval test " << time(el, 5, 200) << " ms" << std::endl; + cout << "JSON-RPC C++ eval test " << time(el, 5, 200) << " ms" << endl; return true; } @@ -267,13 +326,17 @@ const bool testEvalCppPerf() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::server::testGet(); tuscany::server::testGetPerf(); tuscany::server::testPost(); tuscany::server::testPostPerf(); +#ifdef _REENTRANT tuscany::server::testPostThreadPerf(); +#else + tuscany::server::testPostForkPerf(); +#endif tuscany::server::testEval(); tuscany::server::testEvalPerf(); tuscany::server::testPut(); @@ -281,7 +344,7 @@ int main() { tuscany::server::testEvalCpp(); tuscany::server::testEvalCppPerf(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/server/impl-test.cpp b/sca-cpp/trunk/modules/server/impl-test.cpp index 171a78f2d5..d2a45c2fa9 100644 --- a/sca-cpp/trunk/modules/server/impl-test.cpp +++ b/sca-cpp/trunk/modules/server/impl-test.cpp @@ -23,7 +23,7 @@ * Test component implementation. */ -#include <string> +#include "string.hpp" #include "function.hpp" #include "list.hpp" @@ -34,24 +34,24 @@ namespace tuscany { namespace server { -const failable<value, std::string> get(unused const list<value>& params) { - return value(std::string("Hey")); +const failable<value> get(unused const list<value>& params) { + return value(string("Hey")); } -const failable<value, std::string> post(unused const list<value>& params) { - return value(std::string("1234")); +const failable<value> post(unused const list<value>& params) { + return value(string("1234")); } -const failable<value, std::string> put(unused const list<value>& params) { +const failable<value> put(unused const list<value>& params) { return value(true); } -const failable<value, std::string> del(unused const list<value>& params) { +const failable<value> del(unused const list<value>& params) { return value(true); } -const failable<value, std::string> hello(const list<value>& params) { - return value(std::string("hello ") + std::string(car(params))); +const failable<value> hello(const list<value>& params) { + return value(string("hello ") + string(car(params))); } } @@ -71,7 +71,7 @@ const tuscany::value eval(const tuscany::list<tuscany::value>& params) { return tuscany::server::del(cdr(params)); if (func == "hello") return tuscany::server::hello(cdr(params)); - return tuscany::mkfailure<tuscany::value, std::string>(std::string("Function not supported: ") + std::string(func)); + return tuscany::mkfailure<tuscany::value>(tuscany::string("Function not supported: ") + func); } } diff --git a/sca-cpp/trunk/modules/server/mod-cpp.hpp b/sca-cpp/trunk/modules/server/mod-cpp.hpp index 664e9d2e41..2cf2e540d6 100644 --- a/sca-cpp/trunk/modules/server/mod-cpp.hpp +++ b/sca-cpp/trunk/modules/server/mod-cpp.hpp @@ -27,9 +27,8 @@ * component implementations. */ -#include <string> -#include <iostream> -#include <fstream> +#include "string.hpp" +#include "stream.hpp" #include "function.hpp" #include "list.hpp" @@ -65,12 +64,12 @@ struct evalImplementation { /** * Read a C++ component implementation. */ -const failable<lambda<value(const list<value>&)>, std::string> readImplementation(const std::string path, const list<value>& px) { - const failable<lib, std::string> ilib(dynlib(path + dynlibExt)); +const failable<lambda<value(const list<value>&)> > readImplementation(const string& path, const list<value>& px) { + const failable<lib> ilib(dynlib(path + dynlibExt)); if (!hasContent(ilib)) - return mkfailure<lambda<value(const list<value>&)>, std::string>(reason(ilib)); + return mkfailure<lambda<value(const list<value>&)> >(reason(ilib)); - const failable<lambda<value(const list<value>&)>, std::string> impl(dynlambda<value(const list<value>&)>("eval", content(ilib))); + const failable<lambda<value(const list<value>&)> > impl(dynlambda<value(const list<value>&)>("eval", content(ilib))); if (!hasContent(impl)) return impl; return lambda<value(const list<value>&)>(evalImplementation(content(ilib), content(impl), px)); diff --git a/sca-cpp/trunk/modules/server/mod-eval.cpp b/sca-cpp/trunk/modules/server/mod-eval.cpp index d8354c6a58..8e8870dd52 100644 --- a/sca-cpp/trunk/modules/server/mod-eval.cpp +++ b/sca-cpp/trunk/modules/server/mod-eval.cpp @@ -23,15 +23,11 @@ * HTTPD module used to eval component implementations. */ -#include <string> -#include <iostream> -#include <sstream> -#include <fstream> - +#include "string.hpp" +#include "stream.hpp" #include "function.hpp" #include "list.hpp" #include "tree.hpp" -#include "slist.hpp" #include "value.hpp" #include "element.hpp" #include "monad.hpp" @@ -58,9 +54,10 @@ class ServerConf { public: ServerConf(server_rec* s) : s(s), home(""), wiringServerName("") { } + const server_rec* s; - std::string home; - std::string wiringServerName; + string home; + string wiringServerName; }; /** @@ -71,8 +68,8 @@ public: DirConf(char* dirspec) : dirspec(dirspec), contributionPath(""), compositeName("") { } const char* dirspec; - std::string contributionPath; - std::string compositeName; + string contributionPath; + string compositeName; list<value> implementations; }; @@ -80,16 +77,16 @@ public: * Convert a result represented as a content + failure pair to a * failable monad. */ -const failable<value, std::string> failableResult(const list<value>& v) { +const failable<value> failableResult(const list<value>& v) { if (isNil(cdr(v))) return car(v); - return mkfailure<value, std::string>(cadr(v)); + return mkfailure<value>(string(cadr(v))); } /** * Handle an HTTP GET. */ -const failable<int, std::string> get(request_rec* r, const lambda<value(const list<value>&)>& impl) { +const failable<int> get(request_rec* r, const lambda<value(const list<value>&)>& impl) { debug(r->uri, "modeval::get::uri"); // Inspect the query string @@ -102,12 +99,12 @@ const failable<int, std::string> get(request_rec* r, const lambda<value(const li // Extract the request id, method and params const value id = cadr(ia); - const value func = std::string(cadr(ma)).c_str(); + const value func = c_str(string(cadr(ma))); // Apply the requested function - const failable<value, std::string> val = failableResult(impl(cons(func, httpd::queryParams(args)))); + const failable<value> val = failableResult(impl(cons(func, httpd::queryParams(args)))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); // Return JSON result json::JSONContext cx; @@ -115,58 +112,58 @@ const failable<int, std::string> get(request_rec* r, const lambda<value(const li } // Evaluate an ATOM GET request and return an ATOM feed - const list<value> path(httpd::path(r->uri)); + const list<value> path(httpd::pathValues(r->uri)); if (isNil(cddr(path))) { - const failable<value, std::string> val = failableResult(impl(cons<value>("getall", list<value>()))); + const failable<value> val = failableResult(impl(cons<value>("getall", list<value>()))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); return httpd::writeResult(atom::writeATOMFeed(atom::feedValuesToElements(content(val))), "application/atom+xml;type=feed", r); } // Evaluate an ATOM GET and return an ATOM entry - const failable<value, std::string> val = failableResult(impl(cons<value>("get", mklist<value>(caddr(path))))); + const failable<value> val = failableResult(impl(cons<value>("get", mklist<value>(caddr(path))))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); return httpd::writeResult(atom::writeATOMEntry(atom::entryValuesToElements(content(val))), "application/atom+xml;type=entry", r); } /** * Handle an HTTP POST. */ -const failable<int, std::string> post(request_rec* r, const lambda<value(const list<value>&)>& impl) { - const list<std::string> ls = httpd::read(r); +const failable<int> post(request_rec* r, const lambda<value(const list<value>&)>& impl) { + const list<string> ls = httpd::read(r); debug(r->uri, "modeval::post::url"); debug(ls, "modeval::post::input"); // Evaluate a JSON-RPC request and return a JSON result - const std::string ct = httpd::contentType(r); - if (ct.find("application/json-rpc") != std::string::npos || ct.find("text/plain") != std::string::npos) { + const string ct = httpd::contentType(r); + if (contains(ct, "application/json-rpc") || contains(ct, "text/plain")) { json::JSONContext cx; const list<value> json = elementsToValues(content(json::readJSON(ls, cx))); const list<list<value> > args = httpd::postArgs(json); // Extract the request id, method and params const value id = cadr(assoc(value("id"), args)); - const value func = std::string(cadr(assoc(value("method"), args))).c_str(); + const value func = c_str(cadr(assoc(value("method"), args))); const list<value> params = (list<value>)cadr(assoc(value("params"), args)); // Evaluate the request expression - const failable<value, std::string> val = failableResult(impl(cons<value>(func, params))); + const failable<value> val = failableResult(impl(cons<value>(func, params))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); // Return JSON result return httpd::writeResult(json::jsonResult(id, content(val), cx), "application/json-rpc", r); } // Evaluate an ATOM POST request and return the created resource location - if (ct.find("application/atom+xml") != std::string::npos) { + if (contains(ct, "application/atom+xml")) { // Evaluate the request expression const value entry = atom::entryValue(content(atom::readEntry(ls))); - const failable<value, std::string> val = failableResult(impl(cons<value>("post", mklist<value>(entry)))); + const failable<value> val = failableResult(impl(cons<value>("post", mklist<value>(entry)))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); // Return the created resource location apr_table_setn(r->headers_out, "Location", apr_pstrdup(r->pool, httpd::url(content(val), r))); @@ -180,17 +177,17 @@ const failable<int, std::string> post(request_rec* r, const lambda<value(const l /** * Handle an HTTP PUT. */ -const failable<int, std::string> put(request_rec* r, const lambda<value(const list<value>&)>& impl) { - const list<std::string> ls = httpd::read(r); +const failable<int> put(request_rec* r, const lambda<value(const list<value>&)>& impl) { + const list<string> ls = httpd::read(r); debug(r->uri, "modeval::put::url"); debug(ls, "modeval::put::input"); // Evaluate an ATOM PUT request - const list<value> path(httpd::path(r->uri)); + const list<value> path(httpd::pathValues(r->uri)); const value entry = atom::entryValue(content(atom::readEntry(ls))); - const failable<value, std::string> val = failableResult(impl(cons<value>("put", mklist<value>(caddr(path), entry)))); + const failable<value> val = failableResult(impl(cons<value>("put", mklist<value>(caddr(path), entry)))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); if (val == value(false)) return HTTP_NOT_FOUND; return OK; @@ -199,14 +196,14 @@ const failable<int, std::string> put(request_rec* r, const lambda<value(const li /** * Handle an HTTP DELETE. */ -const failable<int, std::string> del(request_rec* r, const lambda<value(const list<value>&)>& impl) { +const failable<int> del(request_rec* r, const lambda<value(const list<value>&)>& impl) { debug(r->uri, "modeval::delete::url"); // Evaluate an ATOM delete request - const list<value> path(httpd::path(r->uri)); - const failable<value, std::string> val = failableResult(impl(cons<value>("delete", mklist<value>(caddr(path))))); + const list<value> path(httpd::pathValues(r->uri)); + const failable<value> val = failableResult(impl(cons<value>("delete", mklist<value>(caddr(path))))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); if (val == value(false)) return HTTP_NOT_FOUND; return OK; @@ -216,6 +213,7 @@ const failable<int, std::string> del(request_rec* r, const lambda<value(const li * Translate a component request. */ int translate(request_rec *r) { + gc_scoped_pool pool(r->pool); if (strncmp(r->uri, "/components/", 12) != 0) return DECLINED; r->handler = "mod_tuscany_eval"; @@ -226,6 +224,7 @@ int translate(request_rec *r) { * HTTP request handler. */ int handler(request_rec *r) { + gc_scoped_pool pool(r->pool); if(strcmp(r->handler, "mod_tuscany_eval")) return DECLINED; httpdDebugRequest(r, "modeval::handler::input"); @@ -237,7 +236,7 @@ int handler(request_rec *r) { // Get the component implementation lambda DirConf& dc = httpd::dirConf<DirConf>(r, &mod_tuscany_eval); - const list<value> path(httpd::path(r->uri)); + const list<value> path(httpd::pathValues(r->uri)); const list<value> impl(assoctree<value>(cadr(path), dc.implementations)); if (isNil(impl)) return HTTP_NOT_FOUND; @@ -260,11 +259,11 @@ int handler(request_rec *r) { /** * Convert a list of component references to a list of HTTP proxy lambdas. */ -const value mkproxy(const value& ref, const std::string& base) { - return lambda<value(const list<value>&)>(http::proxy(base + std::string(scdl::name(ref)))); +const value mkproxy(const value& ref, const string& base) { + return lambda<value(const list<value>&)>(http::proxy(base + string(scdl::name(ref)))); } -const list<value> proxies(const list<value>& refs, const std::string& base) { +const list<value> proxies(const list<value>& refs, const string& base) { if (isNil(refs)) return refs; return cons(mkproxy(car(refs), base), proxies(cdr(refs), base)); @@ -274,31 +273,31 @@ const list<value> proxies(const list<value>& refs, const std::string& base) { * Return a configured component implementation. * For now only Scheme and C++ implementations are supported. */ -const failable<lambda<value(const list<value>&)>, std::string> readImplementation(const std::string& itype, const std::string& path, const list<value>& px) { - if (itype.find(".scheme") != std::string::npos) +const failable<lambda<value(const list<value>&)> > readImplementation(const string& itype, const string& path, const list<value>& px) { + if (contains(itype, ".scheme")) return scm::readImplementation(path, px); - if (itype.find(".cpp") != std::string::npos) + if (contains(itype, ".cpp")) return cpp::readImplementation(path, px); - return mkfailure<lambda<value(const list<value>&)>, std::string>("Unsupported implementation type: " + itype); + return mkfailure<lambda<value(const list<value>&)> >(string("Unsupported implementation type: ") + itype); } const value confImplementation(DirConf& dc, ServerConf& sc, server_rec& server, const value& comp) { const value impl = scdl::implementation(comp); - const std::string path = dc.contributionPath + std::string(scdl::uri(impl)); + const string path = dc.contributionPath + string(scdl::uri(impl)); // Convert component references to configured proxy lambdas - std::ostringstream base; + ostringstream base; if (sc.wiringServerName == "") base << (server.server_scheme == NULL? "http" : server.server_scheme) << "://" << (server.server_hostname == NULL? "localhost" : server.server_hostname) << ":" << (server.port == 0? 80 : server.port) - << "/references/" << std::string(scdl::name(comp)) << "/"; + << "/references/" << string(scdl::name(comp)) << "/"; else - base << sc.wiringServerName << "/references/" << std::string(scdl::name(comp)) << "/"; - const list<value> px(proxies(scdl::references(comp), base.str())); + base << sc.wiringServerName << "/references/" << string(scdl::name(comp)) << "/"; + const list<value> px(proxies(scdl::references(comp), str(base))); // Read and configure the implementation - const failable<lambda<value(const list<value>&)>, std::string> cimpl(readImplementation(elementName(impl), path, px)); + const failable<lambda<value(const list<value>&)> > cimpl(readImplementation(elementName(impl), path, px)); if (!hasContent(cimpl)) return reason(cimpl); return content(cimpl); @@ -320,10 +319,10 @@ const list<value> componentToImplementationTree(DirConf& dc, ServerConf& sc, ser /** * Read the components declared in a composite. */ -const failable<list<value>, std::string> readComponents(const std::string& path) { - std::ifstream is(path); - if (is.fail() || is.bad()) - return mkfailure<list<value>, std::string>("Could not read composite: " + path); +const failable<list<value> > readComponents(const string& path) { + ifstream is(path); + if (fail(is)) + return mkfailure<list<value> >(string("Could not read composite: ") + path); return scdl::components(readXML(streamList(is))); } @@ -333,7 +332,7 @@ const failable<list<value>, std::string> readComponents(const std::string& path) const bool confComponents(DirConf& dc, ServerConf& sc, server_rec& server) { if (dc.contributionPath == "" || dc.compositeName == "") return true; - const failable<list<value>, std::string> comps = readComponents(dc.contributionPath + dc.compositeName); + const failable<list<value> > comps = readComponents(dc.contributionPath + dc.compositeName); if (!hasContent(comps)) return true; dc.implementations = componentToImplementationTree(dc, sc, server, content(comps)); @@ -345,16 +344,19 @@ const bool confComponents(DirConf& dc, ServerConf& sc, server_rec& server) { * Configuration commands. */ const char *confHome(cmd_parms *cmd, unused void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval); sc.home = arg; return NULL; } const char *confWiringServerName(cmd_parms *cmd, unused void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval); sc.wiringServerName = arg; return NULL; } const char *confContribution(cmd_parms *cmd, void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval); DirConf& dc = *(DirConf*)c; dc.contributionPath = arg; @@ -362,6 +364,7 @@ const char *confContribution(cmd_parms *cmd, void *c, const char *arg) { return NULL; } const char *confComposite(cmd_parms *cmd, void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval); DirConf& dc = *(DirConf*)c; dc.compositeName = arg; @@ -384,10 +387,11 @@ int postConfig(unused apr_pool_t *p, unused apr_pool_t *plog, unused apr_pool_t return OK; } -void childInit(unused apr_pool_t* p, server_rec* svr_rec) { +void childInit(apr_pool_t* p, server_rec* svr_rec) { + gc_scoped_pool pool(p); ServerConf* c = (ServerConf*)ap_get_module_config(svr_rec->module_config, &mod_tuscany_eval); if(c == NULL) { - std::cerr << "[Tuscany] Due to one or more errors mod_tuscany_eval loading failed. Causing apache to stop loading." << std::endl; + cerr << "[Tuscany] Due to one or more errors mod_tuscany_eval loading failed. Causing apache to stop loading." << endl; exit(APEXIT_CHILDFATAL); } } diff --git a/sca-cpp/trunk/modules/server/mod-scm.hpp b/sca-cpp/trunk/modules/server/mod-scm.hpp index c454c6a216..887b1de968 100644 --- a/sca-cpp/trunk/modules/server/mod-scm.hpp +++ b/sca-cpp/trunk/modules/server/mod-scm.hpp @@ -27,10 +27,8 @@ * component implementations. */ -#include <string> -#include <iostream> -#include <fstream> - +#include "string.hpp" +#include "stream.hpp" #include "function.hpp" #include "list.hpp" #include "value.hpp" @@ -65,12 +63,12 @@ struct evalImplementation { const value operator()(const list<value>& params) const { const value expr = cons<value>(car(params), append(eval::quotedParameters(cdr(params)), px)); debug(expr, "modeval::scm::evalImplementation::input"); - gc_pool pool; + gc_pool pool(gc_current_pool()); eval::Env globalEnv = eval::setupEnvironment(pool); const value val = eval::evalScript(expr, impl, globalEnv, pool); debug(val, "modeval::scm::evalImplementation::result"); if (isNil(val)) - return mklist<value>(value(), std::string("Could not evaluate expression")); + return mklist<value>(value(), string("Could not evaluate expression")); return mklist<value>(val); } }; @@ -78,13 +76,13 @@ struct evalImplementation { /** * Read a script component implementation. */ -const failable<lambda<value(const list<value>&)>, std::string> readImplementation(const std::string path, const list<value>& px) { - std::ifstream is(path.c_str(), std::ios_base::in); - if (is.fail() || is.bad()) - return mkfailure<lambda<value(const list<value>&)>, std::string>("Could not read implementation: " + path); +const failable<lambda<value(const list<value>&)> > readImplementation(const string& path, const list<value>& px) { + ifstream is(path); + if (fail(is)) + return mkfailure<lambda<value(const list<value>&)> >(string("Could not read implementation: ") + path); const value impl = eval::readScript(is); if (isNil(impl)) - return mkfailure<lambda<value(const list<value>&)>, std::string>("Could not read implementation: " + path); + return mkfailure<lambda<value(const list<value>&)> >(string("Could not read implementation: ") + path); return lambda<value(const list<value>&)>(evalImplementation(impl, px)); } diff --git a/sca-cpp/trunk/modules/server/mod-wiring.cpp b/sca-cpp/trunk/modules/server/mod-wiring.cpp index 1bb5d1a687..6b4308edda 100644 --- a/sca-cpp/trunk/modules/server/mod-wiring.cpp +++ b/sca-cpp/trunk/modules/server/mod-wiring.cpp @@ -26,13 +26,9 @@ #include <sys/stat.h> -#include <string> -#include <iostream> -#include <sstream> -#include <fstream> - +#include "string.hpp" +#include "stream.hpp" #include "list.hpp" -#include "slist.hpp" #include "tree.hpp" #include "value.hpp" #include "debug.hpp" @@ -56,8 +52,8 @@ public: ServerConf(server_rec* s) : s(s), home(""), wiringServerName("") { } const server_rec* s; - std::string home; - std::string wiringServerName; + string home; + string wiringServerName; }; /** @@ -73,8 +69,8 @@ public: DirConf(char* dirspec) : dirspec(dirspec), contributionPath(""), compositeName("") { } const char* dirspec; - std::string contributionPath; - std::string compositeName; + string contributionPath; + string compositeName; list<value> references; list<value> services; }; @@ -82,8 +78,8 @@ public: /** * Returns true if a URI is absolute. */ -const bool isAbsolute(const std::string& uri) { - return uri.find("://") != std::string::npos; +const bool isAbsolute(const string& uri) { + return contains(uri, "://"); } /** @@ -96,7 +92,7 @@ int translateReference(request_rec *r) { // Find the requested component DirConf& dc = httpd::dirConf<DirConf>(r, &mod_tuscany_wiring); - const list<value> rpath(httpd::path(r->uri)); + const list<value> rpath(httpd::pathValues(r->uri)); const list<value> comp(assoctree(cadr(rpath), dc.references)); if (isNil(comp)) return HTTP_NOT_FOUND; @@ -105,26 +101,26 @@ int translateReference(request_rec *r) { const list<value> ref(assoctree<value>(caddr(rpath), cadr(comp))); if (isNil(ref)) return HTTP_NOT_FOUND; - const std::string target(cadr(ref)); + const string target(cadr(ref)); debug(target, "modwiring::translateReference::target"); // Route to an absolute target URI using mod_proxy or an HTTP client redirect if (isAbsolute(target)) { if (useModProxy) { - r->filename = apr_pstrdup(r->pool, std::string("proxy:" + target).c_str()); + r->filename = apr_pstrdup(r->pool, c_str(string("proxy:") + target)); r->proxyreq = PROXYREQ_REVERSE; r->handler = "proxy-server"; return OK; } r->status = HTTP_MOVED_TEMPORARILY; - apr_table_setn(r->headers_out, "Location", apr_pstrdup(r->pool, target.c_str())); + apr_table_setn(r->headers_out, "Location", apr_pstrdup(r->pool, c_str(target))); r->handler = "mod_tuscany_wiring"; return OK; } // Route to a relative target URI using a local internal redirect - r->filename = apr_pstrdup(r->pool, std::string("/redirect:/components/" + target).c_str()); + r->filename = apr_pstrdup(r->pool, c_str(string("/redirect:/components/") + target)); r->handler = "mod_tuscany_wiring"; return OK; } @@ -161,7 +157,7 @@ int translateService(request_rec *r) { // Find the requested component DirConf& dc = httpd::dirConf<DirConf>(r, &mod_tuscany_wiring); - const list<value> path(httpd::path(r->uri)); + const list<value> path(httpd::pathValues(r->uri)); const list<value> svc(assocPath(path, dc.services)); if (isNil(svc)) return DECLINED; @@ -172,9 +168,11 @@ int translateService(request_rec *r) { debug(target, "modwiring::translateService::target"); // Dispatch to the target component using a local internal redirect - const std::string redir(std::string("/redirect:/components") + httpd::path(target)); + const string p(httpd::path(target)); + debug(p, "modwiring::translateService::path"); + const string redir(string("/redirect:/components") + httpd::path(target)); debug(redir, "modwiring::translateService::redirect"); - r->filename = apr_pstrdup(r->pool, redir.c_str()); + r->filename = apr_pstrdup(r->pool, c_str(redir)); r->handler = "mod_tuscany_wiring"; return OK; } @@ -184,6 +182,7 @@ int translateService(request_rec *r) { * to the target component. */ int translate(request_rec *r) { + gc_scoped_pool pool(r->pool); if (!strncmp(r->uri, "/components/", 12) != 0) return DECLINED; @@ -198,11 +197,11 @@ int translate(request_rec *r) { /** * Construct a redirect URI. */ -const std::string redirect(const std::string& file, const std::string& pi) { +const string redirect(const string& file, const string& pi) { return file + pi; } -const std::string redirect(const std::string& file, const std::string& pi, const std::string& args) { +const string redirect(const string& file, const string& pi, const string& args) { return file + pi + "?" + args; } @@ -210,6 +209,7 @@ const std::string redirect(const std::string& file, const std::string& pi, const * HTTP request handler, redirect to a target component. */ int handler(request_rec *r) { + gc_scoped_pool pool(r->pool); if(strcmp(r->handler, "mod_tuscany_wiring")) return DECLINED; httpdDebugRequest(r, "modwiring::handler::input"); @@ -222,20 +222,20 @@ int handler(request_rec *r) { debug(r->path_info, "modwiring::handler::path info"); if (r->args == NULL) { - ap_internal_redirect(apr_pstrdup(r->pool, redirect(r->filename + 10, r->path_info).c_str()), r); + ap_internal_redirect(apr_pstrdup(r->pool, c_str(redirect(string(r->filename + 10), string(r->path_info)))), r); return OK; } - ap_internal_redirect(apr_pstrdup(r->pool, redirect(r->filename + 10, r->path_info, r->args).c_str()), r); + ap_internal_redirect(apr_pstrdup(r->pool, c_str(redirect(string(r->filename + 10), string(r->path_info), string(r->args)))), r); return OK; } /** * Read the components declared in a composite. */ -const failable<list<value>, std::string> readComponents(const std::string& path) { - std::ifstream is(path); - if (is.fail() || is.bad()) - return mkfailure<list<value>, std::string>("Could not read composite: " + path); +const failable<list<value> > readComponents(const string& path) { + ifstream is(path); + if (fail(is)) + return mkfailure<list<value> >(string("Could not read composite: ") + path); return scdl::components(readXML(streamList(is))); } @@ -261,23 +261,23 @@ const list<value> componentReferenceToTargetTree(const list<value>& c) { * Return a tree of service-URI-path + component-name pairs. Service-URI-paths are * represented as lists of URI path fragments. */ -const list<value> defaultBindingURI(const std::string& cn, const std::string& sn) { +const list<value> defaultBindingURI(const string& cn, const string& sn) { return mklist<value>(cn, sn); } -const list<value> bindingToComponentAssoc(const std::string& cn, const std::string& sn, const list<value>& b) { +const list<value> bindingToComponentAssoc(const string& cn, const string& sn, const list<value>& b) { if (isNil(b)) return b; const value uri(scdl::uri(car(b))); if (isNil(uri)) return cons<value>(mklist<value>(defaultBindingURI(cn, sn), cn), bindingToComponentAssoc(cn, sn, cdr(b))); - return cons<value>(mklist<value>(httpd::path(std::string(uri).c_str()), cn), bindingToComponentAssoc(cn, sn, cdr(b))); + return cons<value>(mklist<value>(httpd::pathValues(c_str(string(uri))), cn), bindingToComponentAssoc(cn, sn, cdr(b))); } -const list<value> serviceToComponentAssoc(const std::string& cn, const list<value>& s) { +const list<value> serviceToComponentAssoc(const string& cn, const list<value>& s) { if (isNil(s)) return s; - const std::string sn(scdl::name(car(s))); + const string sn(scdl::name(car(s))); const list<value> btoc(bindingToComponentAssoc(cn, sn, scdl::bindings(car(s)))); if (isNil(btoc)) return cons<value>(mklist<value>(defaultBindingURI(cn, sn), cn), serviceToComponentAssoc(cn, cdr(s))); @@ -300,7 +300,7 @@ const list<value> uriToComponentTree(const list<value>& c) { const bool confComponents(DirConf& dc) { if (dc.contributionPath == "" || dc.compositeName == "") return true; - const failable<list<value>, std::string> comps = readComponents(dc.contributionPath + dc.compositeName); + const failable<list<value> > comps = readComponents(dc.contributionPath + dc.compositeName); if (!hasContent(comps)) return true; dc.references = componentReferenceToTargetTree(content(comps)); @@ -314,22 +314,26 @@ const bool confComponents(DirConf& dc) { * Configuration commands. */ const char *confHome(cmd_parms *cmd, unused void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_wiring); sc.home = arg; return NULL; } const char *confWiringServerName(cmd_parms *cmd, unused void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_wiring); sc.wiringServerName = arg; return NULL; } -const char *confContribution(unused cmd_parms *cmd, void *c, const char *arg) { +const char *confContribution(cmd_parms *cmd, void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); DirConf& dc = *(DirConf*)c; dc.contributionPath = arg; confComponents(dc); return NULL; } -const char *confComposite(unused cmd_parms *cmd, void *c, const char *arg) { +const char *confComposite(cmd_parms *cmd, void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); DirConf& dc = *(DirConf*)c; dc.compositeName = arg; confComponents(dc); @@ -351,10 +355,11 @@ int postConfig(unused apr_pool_t *p, unused apr_pool_t *plog, unused apr_pool_t return OK; } -void childInit(unused apr_pool_t* p, server_rec* svr_rec) { +void childInit(apr_pool_t* p, server_rec* svr_rec) { + gc_scoped_pool pool(p); ServerConf *conf = (ServerConf*)ap_get_module_config(svr_rec->module_config, &mod_tuscany_wiring); if(conf == NULL) { - std::cerr << "[Tuscany] Due to one or more errors mod_tuscany_wiring loading failed. Causing apache to stop loading." << std::endl; + cerr << "[Tuscany] Due to one or more errors mod_tuscany_wiring loading failed. Causing apache to stop loading." << endl; exit(APEXIT_CHILDFATAL); } } diff --git a/sca-cpp/trunk/test/store-script/store-script-test.cpp b/sca-cpp/trunk/test/store-script/store-script-test.cpp index add5cb75e5..a85b661b43 100644 --- a/sca-cpp/trunk/test/store-script/store-script-test.cpp +++ b/sca-cpp/trunk/test/store-script/store-script-test.cpp @@ -25,12 +25,10 @@ #include <assert.h> #include <regex.h> -#include <iostream> -#include <fstream> -#include <string> +#include "stream.hpp" +#include "string.hpp" #include "list.hpp" #include "driver.hpp" -#include "slist.hpp" #include "xml.hpp" #include "../json/json.hpp" @@ -38,51 +36,47 @@ namespace store { using namespace tuscany; -bool contains(const std::string& str, const std::string& pattern) { - return str.find(pattern) != std::string::npos; -} - bool testScript() { - std::ifstream is("store-script.scm", std::ios_base::in); - std::ostringstream os; - eval::evalDriverRun(is, os); - - assert(contains(os.str(), "(\"Sample Feed\" \"")); - assert(contains(os.str(), "\" (\"Item\" \"")); - assert(contains(os.str(), "\" ((javaClass \"services.Item\") (name \"Orange\") (currencyCode \"USD\") (currencySymbol \"$\") (price 3.55))) (\"Item\" \"")); - assert(contains(os.str(), "\" ((javaClass \"services.Item\") (name \"Apple\") (currencyCode \"USD\") (currencySymbol \"$\") (price 2.99))))")); + gc_scoped_pool pool; + + ifstream is("store-script.scm"); + ostringstream os; + eval::evalDriverRun(is, os, pool); + assert(contains(str(os), "(\"Sample Feed\" \"")); + assert(contains(str(os), "\" (\"Item\" \"")); + assert(contains(str(os), "\" ((javaClass \"services.Item\") (name \"Orange\") (currencyCode \"USD\") (currencySymbol \"$\") (price 3.55))) (\"Item\" \"")); + assert(contains(str(os), "\" ((javaClass \"services.Item\") (name \"Apple\") (currencyCode \"USD\") (currencySymbol \"$\") (price 2.99))))")); return true; } bool testEval() { { - std::ifstream is("store-script.scm", std::ios_base::in); - std::ostringstream os; + gc_scoped_pool pool; + ifstream is("store-script.scm"); + ostringstream os; eval::setupDisplay(os); - - gc_pool pool; eval::Env globalEnv = eval::setupEnvironment(pool); - const value exp(mklist<value>("storeui_service", std::string("getcatalog"))); + const value exp(mklist<value>("storeui_service", string("getcatalog"))); const value val = eval::evalScript(exp, is, globalEnv, pool); - std::ostringstream vs; + ostringstream vs; vs << val; - assert(contains(vs.str(), "(((javaClass \"services.Item\") (name \"Apple\") (currencyCode \"USD\") (currencySymbol \"$\") (price 2.99)) ((javaClass \"services.Item\") (name \"Orange\") (currencyCode \"USD\") (currencySymbol \"$\") (price 3.55)) ((javaClass \"services.Item\") (name \"Pear\") (currencyCode \"USD\") (currencySymbol \"$\") (price 1.55)))")); + assert(contains(str(vs), "(((javaClass \"services.Item\") (name \"Apple\") (currencyCode \"USD\") (currencySymbol \"$\") (price 2.99)) ((javaClass \"services.Item\") (name \"Orange\") (currencyCode \"USD\") (currencySymbol \"$\") (price 3.55)) ((javaClass \"services.Item\") (name \"Pear\") (currencyCode \"USD\") (currencySymbol \"$\") (price 1.55)))")); } { - std::ifstream is("store-script.scm", std::ios_base::in); - std::ostringstream os; + gc_scoped_pool pool; + ifstream is("store-script.scm"); + ostringstream os; eval::setupDisplay(os); - gc_pool pool; eval::Env globalEnv = eval::setupEnvironment(pool); - const value exp(mklist<value>("storeui_service", std::string("gettotal"))); + const value exp(mklist<value>("storeui_service", string("gettotal"))); const value res = eval::evalScript(exp, is, globalEnv, pool); - std::ostringstream rs; + ostringstream rs; rs << res; - assert(contains(rs.str(), "10")); + assert(contains(str(rs), "10")); } return true; } @@ -91,12 +85,12 @@ bool testEval() { int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; store::testScript(); store::testEval(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } |