Performance improvements when running both in multi-threaded and pre-forked HTTPD. Changed memory management to use Apache APR pools instead of ref counting pointers as it's much faster and easier to integrate with the Python and Ruby interpreters. Changed to use simple pool-based string and stream implementations instead of the STL ones, which cause a lots of mutex locks in a multi-threaded environment. Added build options to compile with threading and profiling.

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@895165 13f79535-47bb-0310-9956-ffa450edef68

7 files changed, 168 insertions, 181 deletions

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) {