Removed explicit C++ keywords to let the compiler perform the necessary conversions.

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

7 files changed, 63 insertions, 64 deletions

diff --git a/cpp/sca/modules/eval/driver.hpp b/cpp/sca/modules/eval/driver.hpp
index 582f4f1b08..c45a6a1a6d 100644
--- a/cpp/sca/modules/eval/driver.hpp
+++ b/cpp/sca/modules/eval/driver.hpp
@@ -48,8 +48,7 @@ const bool announceOutput(std::ostream& out, const std::string str) {
 
 const bool userPrint(std::ostream& out, const value object) {
     if(isCompoundProcedure(object))
-        out << makeList(compoundProcedureSymbol, value(procedureParameters(object)), value(procedureBody(object)), value(
-                "<procedure-env>"));
+        out << makeList<value>(compoundProcedureSymbol, procedureParameters(object), procedureBody(object), "<procedure-env>");
     out << object;
     return true;
 }
diff --git a/cpp/sca/modules/eval/environment.hpp b/cpp/sca/modules/eval/environment.hpp
index 46c1716cd8..4abf558cfa 100644
--- a/cpp/sca/modules/eval/environment.hpp
+++ b/cpp/sca/modules/eval/environment.hpp
@@ -37,11 +37,11 @@ namespace tuscany
 typedef value Frame;
 typedef list<value> Env;
 
-const value trueSymbol = value("true");
-const value falseSymbol = value("false");
-const value defineSymbol = value("define");
-const value setSymbol = value("set!");
-const value dotSymbol = value(".");
+const value trueSymbol("true");
+const value falseSymbol("false");
+const value defineSymbol("define");
+const value setSymbol("set!");
+const value dotSymbol(".");
 
 const Env theEmptyEnvironment() {
     return list<value>();
@@ -86,7 +86,7 @@ const Frame makeBinding(const Frame& frameSoFar, const list<value>& variables, c
         return frameSoFar;
     }
     if (isDotVariable(car(variables)))
-        return makeBinding(frameSoFar, cdr(variables), makeList(value(values)));
+        return makeBinding(frameSoFar, cdr(variables), makeList<value>(values));
 
     if (values == list<value>()) {
         if (variables != list<value>())
@@ -96,13 +96,13 @@ const Frame makeBinding(const Frame& frameSoFar, const list<value>& variables, c
 
     const list<value> vars = cons(car(variables), frameVariables(frameSoFar));
     const list<value> vals = cons(car(values), frameValues(frameSoFar));
-    const Frame newFrame = value(cons(value(vars), vals));
+    const Frame newFrame = cons(value(vars), vals);
 
     return makeBinding(newFrame, cdr(variables), cdr(values));
 }
 
 const Frame makeFrame(const list<value>& variables, const list<value> values) {
-    const Frame emptyFrame = value(cons((value)list<value>(), list<value>()));
+    const Frame emptyFrame = cons(value(list<value>()), list<value>());
     return makeBinding(emptyFrame, variables, values);
 }
 
@@ -131,11 +131,11 @@ const value assignmentValue(const value& exp) {
 }
 
 const Frame addBindingToFrame(const value& var, const value& val, const Frame& frame) {
-    return value(cons((value)cons(var, frameVariables(frame)), cons(val, frameValues(frame))));
+    return cons(value(cons(var, frameVariables(frame))), cons(val, frameValues(frame)));
 }
 
 const Env defineVariable(const value& var, const value& val, Env& env) {
-    return value(cons(addBindingToFrame(var, val, firstFrame(env)), cdr(env)));
+    return cons(addBindingToFrame(var, val, firstFrame(env)), cdr(env));
 }
 
 const Env extendEnvironment(const list<value>& vars, const list<value>& vals, const Env& baseEnv) {
@@ -150,8 +150,8 @@ const Env extendEnvironment(const list<value>& vars, const list<value>& vals, co
 
 const Env setupEnvironment() {
     Env env = extendEnvironment(primitiveProcedureNames(), primitiveProcedureObjects(), theEmptyEnvironment());
-    env = defineVariable(trueSymbol, value(true), env);
-    env = defineVariable(falseSymbol, value(false), env);
+    env = defineVariable(trueSymbol, true, env);
+    env = defineVariable(falseSymbol, false, env);
     return env;
 }
 
diff --git a/cpp/sca/modules/eval/eval-test b/cpp/sca/modules/eval/eval-test
index ff394153d1..5505bfd1e8 100755
--- a/cpp/sca/modules/eval/eval-test
+++ b/cpp/sca/modules/eval/eval-test
diff --git a/cpp/sca/modules/eval/eval-test.cpp b/cpp/sca/modules/eval/eval-test.cpp
index c8c86a1666..81f03f1c5e 100644
--- a/cpp/sca/modules/eval/eval-test.cpp
+++ b/cpp/sca/modules/eval/eval-test.cpp
@@ -33,10 +33,10 @@ namespace tuscany {
 
 bool testEnv() {
     Env globalEnv = list<value>();
-    Env env = extendEnvironment(makeList(value("a")), makeList(value(1)), globalEnv);
-    defineVariable(value("x"), value(env), env);
+    Env env = extendEnvironment(makeList<value>("a"), makeList<value>(1), globalEnv);
+    defineVariable("x", env, env);
     //assert(lookupVariableValue(value("x"), env) == env);
-    assert(lookupVariableValue(value("a"), env) == value(1));
+    assert(lookupVariableValue("a", env) == value(1));
     return true;
 }
 
@@ -56,19 +56,19 @@ bool testEnvGC() {
 
 bool testRead() {
     std::istringstream is("abcd");
-    assert(read(is) == value("abcd"));
+    assert(read(is) == "abcd");
 
     std::istringstream is2("123");
     assert(read(is2) == value(123));
 
     std::istringstream is3("(abcd)");
-    assert(read(is3) == value(makeList(value("abcd"))));
+    assert(read(is3) == makeList(value("abcd")));
 
     std::istringstream is4("(abcd xyz)");
-    assert(read(is4) == value(makeList(value("abcd"), value("xyz"))));
+    assert(read(is4) == makeList<value>("abcd", "xyz"));
 
     std::istringstream is5("(abcd (xyz tuv))");
-    assert(read(is5) == value(makeList(value("abcd"), value(makeList(value("xyz"), value("tuv"))))));
+    assert(read(is5) == makeList<value>("abcd", makeList<value>("xyz", "tuv")));
 
     return true;
 }
@@ -133,10 +133,10 @@ bool testEval() {
 }
 
 bool testEvalExpr() {
-    const value exp = value(makeList(value("+"), value(2), value(3)));
+    const value exp = makeList<value>("+", 2, 3);
     Env env = setupEnvironment();
     const value r = eval(exp, env);
-    assert(value(5) == r);
+    assert(r == value(5));
     return true;
 }
 
diff --git a/cpp/sca/modules/eval/eval.hpp b/cpp/sca/modules/eval/eval.hpp
index 28e1d01ffc..783f5c6447 100644
--- a/cpp/sca/modules/eval/eval.hpp
+++ b/cpp/sca/modules/eval/eval.hpp
@@ -67,7 +67,7 @@ static list<value> lambdaBody(const value& exp) {
 }
 
 const value makeProcedure(const list<value>& parameters, const value& body, const Env& env) {
-    return value(makeList(procedureSymbol, value(parameters), body, value(env)));
+    return makeList<value>(procedureSymbol, parameters, body, env);
 }
 
 const bool isApply(const value& exp) {
@@ -129,7 +129,7 @@ const list<value> restExp(const list<value>& seq) {
 }
 
 const value makeBegin(const list<value> seq) {
-    return value(cons(beginSymbol, seq));
+    return cons(beginSymbol, seq);
 }
 
 const value evalSequence(const list<value>& exps, Env& env) {
@@ -152,7 +152,7 @@ const value applyProcedure(const value& procedure, list<value>& arguments) {
 
 const value sequenceToExp(const list<value> exps) {
     if(exps == list<value> ())
-        return value(list<value>());
+        return list<value>();
     if(isLastExp(exps))
         return firstExp(exps);
     return makeBegin(exps);
@@ -181,7 +181,7 @@ const value ifConsequent(const value& exp) {
 const value ifAlternative(const value& exp) {
     if(cdr(cdr(cdr((list<value> )exp))) != list<value> ())
         return car(cdr(cdr(cdr((list<value> )exp))));
-    return value(false);
+    return false;
 }
 
 const bool isCond(const value& exp) {
@@ -197,12 +197,12 @@ const bool isIf(const value& exp) {
 }
 
 const value makeIf(value predicate, value consequent, value alternative) {
-    return value(makeList(ifSymbol, predicate, consequent, alternative));
+    return makeList(ifSymbol, predicate, consequent, alternative);
 }
 
 const value expandClauses(const list<value>& clauses) {
     if(clauses == list<value> ())
-        return value(false);
+        return false;
     const value first = car(clauses);
     const list<value> rest = cdr(clauses);
     if(isCondElseClause(first)) {
@@ -243,7 +243,7 @@ const value eval(const value& exp, Env& env) {
     if(isCond(exp))
         return eval(condToIf(exp), env);
     if(isLambda(exp))
-        return makeProcedure(lambdaParameters(exp), value(lambdaBody(exp)), env);
+        return makeProcedure(lambdaParameters(exp), lambdaBody(exp), env);
     if(isVariable(exp))
         return lookupVariableValue(exp, env);
     if(isApply(exp)) {
diff --git a/cpp/sca/modules/eval/primitive.hpp b/cpp/sca/modules/eval/primitive.hpp
index 04e26178f4..5ee74fa5d4 100644
--- a/cpp/sca/modules/eval/primitive.hpp
+++ b/cpp/sca/modules/eval/primitive.hpp
@@ -50,53 +50,53 @@ const value valueCar(list<value>& args) {
 }
 
 const value valueCdr(list<value>& args) {
-    return value(cdr((list<value> )car(args)));
+    return cdr((list<value> )car(args));
 }
 
 const value valueCons(list<value>& args) {
-    return value(cons(car(args), (list<value> )cadr(args)));
+    return cons(car(args), (list<value> )cadr(args));
 }
 
 const value valueList(list<value>& args) {
-    return value(args);
+    return args;
 }
 
 const value valueNul(list<value>& args) {
-    return value((bool)isNil(car(args)));
+    return (bool)isNil(car(args));
 }
 
 const value valueEqual(list<value>& args) {
-    return value((bool)(car(args) == cadr(args)));
+    return (bool)(car(args) == cadr(args));
 }
 
 const value valueAdd(list<value>& args) {
     if (cdr(args) == list<value>())
-        return value((double)car(args));
-    return value((double)car(args) + (double)cadr(args));
+        return (double)car(args);
+    return (double)car(args) + (double)cadr(args);
 }
 
 const value valueSub(list<value>& args) {
     if (cdr(args) == list<value>())
-        return value(0 - (double)car(args));
-    return value((double)car(args) - (double)cadr(args));
+        return (double)0 - (double)car(args);
+    return (double)car(args) - (double)cadr(args);
 }
 
 const value valueMul(list<value>& args) {
-    return value((double)car(args) * (double)cadr(args));
+    return (double)car(args) * (double)cadr(args);
 }
 
 const value valueDiv(list<value>& args) {
-    return value((double)car(args) / (double)cadr(args));
+    return (double)car(args) / (double)cadr(args);
 }
 
 const value valueDisplay(list<value>& args) {
     *evalOut << car(args);
-    return value(true);
+    return true;
 }
 
 const value valueError(list<value>& args) {
     std::cerr << (std::string)car(args);
-    return value(true);
+    return true;
 }
 
 const value applyPrimitiveProcedure(const value& proc, list<value>& args) {
@@ -127,22 +127,22 @@ const value primitiveImplementation(const list<value>& proc) {
 }
 
 template<typename F> const value primitiveProcedure(const F& f) {
-    return value(makeList(primitiveSymbol, value((lambda<value(list<value>&)>)f)));
+    return makeList<value>(primitiveSymbol, (lambda<value(list<value>&)>)f);
 }
 
 const list<value> primitiveProcedureNames() {
-    list<value> l = makeList(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("+"), l);
-    l = cons(value("-"), l);
-    l = cons(value("*"), l);
-    l = cons(value("/"), l);
-    l = cons(value("equal?"), l);
-    l = cons(value("display"), l);
+    list<value> l = makeList<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>("+", l);
+    l = cons<value>("-", l);
+    l = cons<value>("*", l);
+    l = cons<value>("/", l);
+    l = cons<value>("equal?", l);
+    l = cons<value>("display", l);
     return l;
 }
 
@@ -179,7 +179,7 @@ const value textOfQuotation(const value& exp) {
 }
 
 const value makeLambda(const list<value>& parameters, const list<value>& body) {
-    return value(cons(lambdaSymbol, cons((value)parameters, body)));
+    return cons(lambdaSymbol, cons<value>(parameters, body));
 }
 
 }
diff --git a/cpp/sca/modules/eval/read.hpp b/cpp/sca/modules/eval/read.hpp
index cd9068c017..6baf670a1e 100644
--- a/cpp/sca/modules/eval/read.hpp
+++ b/cpp/sca/modules/eval/read.hpp
@@ -38,8 +38,8 @@
 namespace tuscany
 {
 
-const value rightParenthesis(makeList(value(")")));
-const value leftParenthesis(makeList(value("(")));
+const value rightParenthesis(makeList<value>(")"));
+const value leftParenthesis(makeList<value>("("));
 
 const double stringToNumber(const std::string& str) {
     double d;
@@ -120,7 +120,7 @@ const value readToken(std::istream& in) {
 }
 
 const value readQuoted(std::istream& in) {
-    return value(makeList(quoteSymbol, read(in)));
+    return makeList(quoteSymbol, read(in));
 }
 
 const list<value> readList(const list<value>& listSoFar, std::istream& in) {
@@ -146,7 +146,7 @@ const list<char> readIdentifierHelper(const list<char>& listSoFar, std::istream&
 }
 
 const value readIdentifier(const char chr, std::istream& in) {
-    return value(listToString(readIdentifierHelper(makeList(chr), in)).c_str());
+    return listToString(readIdentifierHelper(makeList(chr), in)).c_str();
 }
 
 const list<char> readStringHelper(const list<char>& listSoFar, std::istream& in) {
@@ -157,7 +157,7 @@ const list<char> readStringHelper(const list<char>& listSoFar, std::istream& in)
 }
 
 const value readString(const char chr, std::istream& in) {
-    return value(listToString(readStringHelper(list<char>(), in)));
+    return listToString(readStringHelper(list<char>(), in));
 }
 
 const list<char> readNumberHelper(const list<char>& listSoFar, std::istream& in) {
@@ -168,13 +168,13 @@ const list<char> readNumberHelper(const list<char>& listSoFar, std::istream& in)
 }
 
 const value readNumber(const char chr, std::istream& in) {
-    return value(stringToNumber(listToString(readNumberHelper(makeList(chr), in))));
+    return stringToNumber(listToString(readNumberHelper(makeList(chr), in)));
 }
 
 const value read(std::istream& in) {
     const value nextToken = readToken(in);
     if(isLeftParenthesis(nextToken))
-        return value(readList(list<value> (), in));
+        return readList(list<value> (), in);
     return nextToken;
 }