diff -urN /usr/ports/net/xmlrpc-c/Makefile net/xmlrpc-c/Makefile --- /usr/ports/net/xmlrpc-c/Makefile Sun Feb 29 12:26:37 2004 +++ net/xmlrpc-c/Makefile Tue Mar 2 22:45:59 2004 @@ -19,26 +19,12 @@ LIB_DEPENDS= wwwcore.1:${PORTSDIR}/www/libwww RUN_DEPENDS= ${SITE_PERL}/Frontier/Client.pm:${PORTSDIR}/net/p5-Frontier-RPC -USE_REINPLACE= yes -USE_LIBTOOL= yes USE_GMAKE= yes +USE_LIBTOOL= yes INSTALLS_SHLIB= yes MAN1= meerkat-app-list.1 xml-rpc-api2cpp.1 xmlrpc-c-config.1 \ query-meerkat.1 xml-rpc-api2txt.1 MAN7= xmlrpc-c.7 -.include - -pre-patch: - @${REINPLACE_CMD} -e 's,,,' \ - ${WRKSRC}/lib/abyss/src/data.c \ - ${WRKSRC}/tools/turbocharger/mod_gzip.c - cd ${WRKSRC}; ${REINPLACE_CMD} -e 's,,,' \ - examples/meerkat-app-list.cc \ - tools/xml-rpc-api2cpp/DataType.cc - -post-install: - @${RM} -f ${PREFIX}/lib/*.la - -.include +.include diff -urN /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.cc net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.cc --- /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.cc Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.cc Tue Mar 2 23:41:05 2004 @@ -0,0 +1,29 @@ +--- examples/interop-client/InteropEchoProxy.cc.orig Wed Apr 25 00:17:25 2001 ++++ examples/interop-client/InteropEchoProxy.cc Tue Mar 2 23:39:39 2004 +@@ -12,7 +12,7 @@ + public: + InteropEchoProxy (const XmlRpcClient& client) + : mClient(client) {} +- InteropEchoProxy (const string& server_url) ++ InteropEchoProxy (const std::string& server_url) + : mClient(XmlRpcClient(server_url)) {} + InteropEchoProxy (const InteropEchoProxy& o) + : mClient(o.mClient) {} +@@ -23,7 +23,7 @@ + } + + /* Echo an arbitrary XML-RPC string. */ +- string echoString (string string1); ++ std::string echoString (std::string string1); + + /* Echo an arbitrary XML-RPC integer. */ + XmlRpcValue::int32 echoInteger (XmlRpcValue::int32 int1); +@@ -55,7 +55,7 @@ + #include + #include "InteropEchoProxy.h" + +-string InteropEchoProxy::echoString (string string1) { ++std::string InteropEchoProxy::echoString (std::string string1) { + XmlRpcValue params = XmlRpcValue::makeArray(); + params.arrayAppendItem(XmlRpcValue::makeString(string1)); + XmlRpcValue result = this->mClient.call("interopEchoTests.echoString", params); diff -urN /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.h net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.h --- /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.h Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-examples::interop-client::InteropEchoProxy.h Tue Mar 2 23:41:16 2004 @@ -0,0 +1,20 @@ +--- examples/interop-client/InteropEchoProxy.h.orig Wed Apr 25 00:17:42 2001 ++++ examples/interop-client/InteropEchoProxy.h Tue Mar 2 23:39:39 2004 +@@ -12,7 +12,7 @@ + public: + InteropEchoProxy (const XmlRpcClient& client) + : mClient(client) {} +- InteropEchoProxy (const string& server_url) ++ InteropEchoProxy (const std::string& server_url) + : mClient(XmlRpcClient(server_url)) {} + InteropEchoProxy (const InteropEchoProxy& o) + : mClient(o.mClient) {} +@@ -23,7 +23,7 @@ + } + + /* Echo an arbitrary XML-RPC string. */ +- string echoString (string string1); ++ std::string echoString (std::string string1); + + /* Echo an arbitrary XML-RPC integer. */ + XmlRpcValue::int32 echoInteger (XmlRpcValue::int32 int1); diff -urN /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::interop-client.cc net/xmlrpc-c/files/patch-examples::interop-client::interop-client.cc --- /usr/ports/net/xmlrpc-c/files/patch-examples::interop-client::interop-client.cc Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-examples::interop-client::interop-client.cc Tue Mar 2 23:41:39 2004 @@ -0,0 +1,108 @@ +--- examples/interop-client/interop-client.cc.orig Thu Jun 28 11:54:08 2001 ++++ examples/interop-client/interop-client.cc Tue Mar 2 23:39:39 2004 +@@ -1,8 +1,8 @@ + // Run various interop test cases against a list of servers. + // This code is incomplete. + +-#include +-#include ++#include ++#include + #include + + #include +@@ -17,13 +17,13 @@ + //========================================================================= + + class TestResults { +- string m_server_name; +- string m_server_url; ++ std::string m_server_name; ++ std::string m_server_url; + XmlRpcValue m_toolkit_info; + XmlRpcValue m_test_results; + + public: +- TestResults(string server_name, string server_url); ++ TestResults(std::string server_name, std::string server_url); + + }; + +@@ -33,24 +33,24 @@ + //========================================================================= + + static void +-run_interop_tests(const string& server_url_file, +- const string& output_html_file) ++run_interop_tests(const std::string& server_url_file, ++ const std::string& output_html_file) + { +- ifstream urls(server_url_file.c_str()); +- ofstream out(output_html_file.c_str()); ++ std::ifstream urls(server_url_file.c_str()); ++ std::ofstream out(output_html_file.c_str()); + + while (!urls.eof()) { +- string url_info; ++ std::string url_info; + getline(urls, url_info); + size_t comma = url_info.find(','); +- if (comma == string::npos) +- throw domain_error("Lines of " + server_url_file + ++ if (comma == std::string::npos) ++ throw std::domain_error("Lines of " + server_url_file + + " must be of the form \"name,url\""); +- string server_name(url_info, 0, comma); +- string server_url(url_info, comma + 1); ++ std::string server_name(url_info, 0, comma); ++ std::string server_url(url_info, comma + 1); + +- cout << "Name: " << server_name << endl; +- cout << "URL: " << server_url << endl << endl; ++ std::cout << "Name: " << server_name << std::endl; ++ std::cout << "URL: " << server_url << std::endl << std::endl; + } + } + +@@ -62,8 +62,8 @@ + // Print out a usage message. + static void usage (void) + { +- cerr << "Usage: interop-client

"; +- cerr << endl; ++ std::cerr << "Usage: interop-client

"; ++ std::cerr << std::endl; + exit(1); + } + +@@ -73,8 +73,8 @@ + // Parse our command-line arguments. + if (argc != 3) + usage(); +- string server_url_file(argv[1]); +- string output_html_file(argv[2]); ++ std::string server_url_file(argv[1]); ++ std::string output_html_file(argv[2]); + + // Start up our client library. + XmlRpcClient::Initialize(NAME, VERSION); +@@ -83,14 +83,14 @@ + try { + run_interop_tests(server_url_file, output_html_file); + } catch (XmlRpcFault& fault) { +- cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode() +- << ": " << fault.getFaultString() << endl; ++ std::cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode() ++ << ": " << fault.getFaultString() << std::endl; + status = 1; +- } catch (logic_error& err) { +- cerr << argv[0] << ": " << err.what() << endl; ++ } catch (std::logic_error& err) { ++ std::cerr << argv[0] << ": " << err.what() << std::endl; + status = 1; + } catch (...) { +- cerr << argv[0] << ": Unknown exception" << endl; ++ std::cerr << argv[0] << ": Unknown exception" << std::endl; + status = 1; + } + diff -urN /usr/ports/net/xmlrpc-c/files/patch-examples::meerkat-app-list.cc net/xmlrpc-c/files/patch-examples::meerkat-app-list.cc --- /usr/ports/net/xmlrpc-c/files/patch-examples::meerkat-app-list.cc Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-examples::meerkat-app-list.cc Tue Mar 2 23:42:04 2004 @@ -0,0 +1,88 @@ +--- examples/meerkat-app-list.cc.orig Wed Apr 25 04:18:36 2001 ++++ examples/meerkat-app-list.cc Tue Mar 2 23:39:39 2004 +@@ -2,8 +2,8 @@ + // For more details about O'Reilly's excellent Meerkat news service, see: + // http://www.oreillynet.com/pub/a/rss/2000/11/14/meerkat_xmlrpc.html */ + +-#include +-#include ++#include ++#include + + #include + +@@ -15,12 +15,9 @@ + static void list_apps (int hours) { + + // Build our time_period parameter. +- ostrstream time_period_stream; +- time_period_stream << hours << "HOUR" << ends; +- string time_period = time_period_stream.str(); +- +- // (Ask the ostrstream to reclaim ownership of its buffer.) +- time_period_stream.freeze(false); ++ std::ostringstream time_period_stream; ++ time_period_stream << hours << "HOUR" << std::ends; ++ std::string time_period = time_period_stream.str(); + + // Assemble our meerkat query recipe. + XmlRpcValue recipe = XmlRpcValue::makeStruct(); +@@ -45,21 +42,21 @@ + XmlRpcValue app = apps.arrayGetItem(i); + + // Get some information about our application. +- string title = app.structGetValue("title").getString(); +- string link = app.structGetValue("link").getString(); +- string description = app.structGetValue("description").getString(); ++ std::string title = app.structGetValue("title").getString(); ++ std::string link = app.structGetValue("link").getString(); ++ std::string description = app.structGetValue("description").getString(); + + // Print a separator line if necessary. + if (first) + first = 0; + else +- cout << endl; ++ std::cout << std::endl; + + // Print this application entry. + if (description.size() > 0) { +- cout << title << endl << description << endl << link << endl; ++ std::cout << title << std::endl << description << std::endl << link << std::endl; + } else { +- cout << title << endl << description << endl << link << endl; ++ std::cout << title << std::endl << description << std::endl << link << std::endl; + } + } + } +@@ -67,8 +64,8 @@ + // Print out a usage message. + static void usage (void) + { +- cerr << "Usage: meekat-app-list [hours]" << endl; +- cerr << "Data from ." << endl; ++ std::cerr << "Usage: meekat-app-list [hours]" << std::endl; ++ std::cerr << "Data from ." << std::endl; + exit(1); + } + +@@ -85,7 +82,7 @@ + if (hours == 0) + usage(); + if (hours > 49) { +- cerr << "It's not nice to ask for > 49 hours at once." << endl; ++ std::cerr << "It's not nice to ask for > 49 hours at once." << std::endl; + exit(1); + } + +@@ -96,8 +93,8 @@ + try { + list_apps(hours); + } catch (XmlRpcFault& fault) { +- cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode() +- << ": " << fault.getFaultString() << endl; ++ std::cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode() ++ << ": " << fault.getFaultString() << std::endl; + status = 1; + } + diff -urN /usr/ports/net/xmlrpc-c/files/patch-src-XmlRpcCpp.h net/xmlrpc-c/files/patch-src-XmlRpcCpp.h --- /usr/ports/net/xmlrpc-c/files/patch-src-XmlRpcCpp.h Thu Nov 14 20:15:42 2002 +++ net/xmlrpc-c/files/patch-src-XmlRpcCpp.h Thu Jan 1 09:00:00 1970 @@ -1,12 +0,0 @@ ---- src/XmlRpcCpp.h.orig Thu Nov 14 09:17:52 2002 -+++ src/XmlRpcCpp.h Thu Nov 14 09:18:17 2002 -@@ -45,8 +45,8 @@ - // work with our version of g++). So this header name is technically wrong. - // Tell me what your compiler does; I can provide some autoconf magic to the - // Right Thing on most platforms. -+using namespace std; - #include --// using namespace std; - - #include - #include diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::XmlRpcCpp.cc net/xmlrpc-c/files/patch-src::XmlRpcCpp.cc --- /usr/ports/net/xmlrpc-c/files/patch-src::XmlRpcCpp.cc Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-src::XmlRpcCpp.cc Tue Mar 2 23:42:42 2004 @@ -0,0 +1,103 @@ +--- src/XmlRpcCpp.cc.orig Sat Apr 14 03:43:55 2001 ++++ src/XmlRpcCpp.cc Tue Mar 2 23:39:39 2004 +@@ -38,7 +38,7 @@ + fault.mFault.fault_string); + } + +-XmlRpcFault::XmlRpcFault (const int faultCode, const string faultString) { ++XmlRpcFault::XmlRpcFault (const int faultCode, const std::string faultString) { + xmlrpc_env_init(&mFault); + xmlrpc_env_set_fault(&mFault, faultCode, + const_cast(faultString.c_str())); +@@ -57,9 +57,9 @@ + xmlrpc_env_clean(&mFault); + } + +-string XmlRpcFault::getFaultString (void) const { ++std::string XmlRpcFault::getFaultString (void) const { + XMLRPC_ASSERT(mFault.fault_occurred); +- return string(mFault.fault_string); ++ return std::string(mFault.fault_string); + } + + +@@ -117,7 +117,7 @@ + return XmlRpcValue(value, CONSUME_REFERENCE); + } + +-XmlRpcValue XmlRpcValue::makeDateTime (const string& dateTime) { ++XmlRpcValue XmlRpcValue::makeDateTime (const std::string& dateTime) { + XmlRpcEnv env; + xmlrpc_value *value; + const char *data = dateTime.c_str(); // Make sure we're not using wchar_t. +@@ -126,7 +126,7 @@ + return XmlRpcValue(value, CONSUME_REFERENCE); + } + +-XmlRpcValue XmlRpcValue::makeString (const string& str) { ++XmlRpcValue XmlRpcValue::makeString (const std::string& str) { + XmlRpcEnv env; + const char *data = str.data(); // Make sure we're not using wchar_t. + size_t size = str.size(); +@@ -196,21 +196,21 @@ + return result; + } + +-string XmlRpcValue::getRawDateTime (void) const { ++std::string XmlRpcValue::getRawDateTime (void) const { + XmlRpcEnv env; + char *result; + xmlrpc_parse_value(env, mValue, "8", &result); + env.throwIfFaultOccurred(); +- return string(result); ++ return std::string(result); + } + +-string XmlRpcValue::getString (void) const { ++std::string XmlRpcValue::getString (void) const { + XmlRpcEnv env; + char *result; + size_t result_len; + xmlrpc_parse_value(env, mValue, "s#", &result, &result_len); + env.throwIfFaultOccurred(); +- return string(result, result_len); ++ return std::string(result, result_len); + + } + +@@ -265,7 +265,7 @@ + return result; + } + +-bool XmlRpcValue::structHasKey (const string& key) { ++bool XmlRpcValue::structHasKey (const std::string& key) { + XmlRpcEnv env; + const char *keystr = key.data(); + size_t keylen = key.size(); +@@ -275,7 +275,7 @@ + return result; + } + +-XmlRpcValue XmlRpcValue::structGetValue (const string& key) { ++XmlRpcValue XmlRpcValue::structGetValue (const std::string& key) { + XmlRpcEnv env; + const char *keystr = key.data(); + size_t keylen = key.size(); +@@ -286,7 +286,7 @@ + return XmlRpcValue(result); + } + +-void XmlRpcValue::structSetValue (const string& key, const XmlRpcValue& value) ++void XmlRpcValue::structSetValue (const std::string& key, const XmlRpcValue& value) + { + XmlRpcEnv env; + const char *keystr = key.data(); +@@ -297,7 +297,7 @@ + } + + void XmlRpcValue::structGetKeyAndValue (const int index, +- string& out_key, ++ std::string& out_key, + XmlRpcValue& out_value) + { + XmlRpcEnv env; diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::XmlRpcCpp.h net/xmlrpc-c/files/patch-src::XmlRpcCpp.h --- /usr/ports/net/xmlrpc-c/files/patch-src::XmlRpcCpp.h Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-src::XmlRpcCpp.h Tue Mar 2 23:42:53 2004 @@ -0,0 +1,97 @@ +--- src/XmlRpcCpp.h.orig Sat Apr 14 03:46:16 2001 ++++ src/XmlRpcCpp.h Tue Mar 2 23:39:39 2004 +@@ -71,12 +71,12 @@ + + public: + XmlRpcFault (const XmlRpcFault &fault); +- XmlRpcFault (const int faultCode, const string faultString); ++ XmlRpcFault (const int faultCode, const std::string faultString); + XmlRpcFault (const xmlrpc_env *env); + ~XmlRpcFault (void); + + int getFaultCode (void) const; +- string getFaultString (void) const; ++ std::string getFaultString (void) const; + xmlrpc_env *getFaultEnv (void); + }; + +@@ -167,8 +167,8 @@ + static XmlRpcValue makeInt (const XmlRpcValue::int32 i); + static XmlRpcValue makeBool (const bool b); + static XmlRpcValue makeDouble (const double d); +- static XmlRpcValue makeDateTime (const string& dateTime); +- static XmlRpcValue makeString (const string& str); ++ static XmlRpcValue makeDateTime (const std::string& dateTime); ++ static XmlRpcValue makeString (const std::string& str); + static XmlRpcValue makeString (const char *const str); + static XmlRpcValue makeString (const char *const str, size_t len); + static XmlRpcValue makeArray (void); +@@ -185,8 +185,8 @@ + XmlRpcValue::int32 getInt (void) const; + bool getBool (void) const; + double getDouble (void) const; +- string getRawDateTime (void) const; +- string getString (void) const; ++ std::string getRawDateTime (void) const; ++ std::string getString (void) const; + XmlRpcValue getArray (void) const; + XmlRpcValue getStruct (void) const; + +@@ -209,11 +209,11 @@ + // Struct functions. These will throw an XmlRpcFault if the value + // isn't a struct. + size_t structSize (void); +- bool structHasKey (const string& key); +- XmlRpcValue structGetValue (const string& key); +- void structSetValue (const string& key, const XmlRpcValue& value); ++ bool structHasKey (const std::string& key); ++ XmlRpcValue structGetValue (const std::string& key); ++ void structSetValue (const std::string& key, const XmlRpcValue& value); + void structGetKeyAndValue (const int index, +- string& out_key, ++ std::string& out_key, + XmlRpcValue& out_value); + }; + +@@ -265,19 +265,19 @@ + class XmlRpcClient { + + private: +- string mServerUrl; ++ std::string mServerUrl; + + public: +- static void Initialize (string appname, string appversion); ++ static void Initialize (std::string appname, std::string appversion); + static void Terminate (void); + +- XmlRpcClient (const string& server_url) : mServerUrl(server_url) {} ++ XmlRpcClient (const std::string& server_url) : mServerUrl(server_url) {} + ~XmlRpcClient (void) {} + + XmlRpcClient (const XmlRpcClient& client); + XmlRpcClient& operator= (const XmlRpcClient& client); + +- XmlRpcValue call (string method_name, XmlRpcValue param_array); ++ XmlRpcValue call (std::string method_name, XmlRpcValue param_array); + }; + + +@@ -299,7 +299,7 @@ + return *this; + } + +-inline void XmlRpcClient::Initialize (string appname, string appversion) { ++inline void XmlRpcClient::Initialize (std::string appname, std::string appversion) { + xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, + const_cast(appname.c_str()), + const_cast(appversion.c_str())); +@@ -309,7 +309,7 @@ + xmlrpc_client_cleanup(); + } + +-inline XmlRpcValue XmlRpcClient::call (string method_name, ++inline XmlRpcValue XmlRpcClient::call (std::string method_name, + XmlRpcValue param_array) + { + XmlRpcEnv env; diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::cpptest.cc net/xmlrpc-c/files/patch-src::cpptest.cc --- /usr/ports/net/xmlrpc-c/files/patch-src::cpptest.cc Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-src::cpptest.cc Tue Mar 2 23:43:04 2004 @@ -0,0 +1,89 @@ +--- src/cpptest.cc.orig Wed May 2 00:26:13 2001 ++++ src/cpptest.cc Tue Mar 2 23:39:39 2004 +@@ -28,15 +28,15 @@ + void test_failure (char* file, int line, char* statement) + { + total_failures++; +- cout << endl +- << file << ":" << line << ": expected (" << statement << ")" << endl; ++ std::cout << std::endl ++ << file << ":" << line << ": expected (" << statement << ")" << std::endl; + } + + #define TEST(statement) \ + do { \ + total_tests++; \ + if ((statement)) { \ +- cout << "."; \ ++ std::cout << "."; \ + } else { \ + test_failure(__FILE__, __LINE__, #statement); \ + } \ +@@ -45,7 +45,7 @@ + #define TEST_PASSED() \ + do { \ + total_tests++; \ +- cout << "."; \ ++ std::cout << "."; \ + } while (0) + + #define TEST_FAILED(reason) \ +@@ -187,7 +187,7 @@ + TEST(XmlRpcValue::makeString("foo").getString() == "foo"); + TEST(XmlRpcValue::makeString("bar", 3).getString() == "bar"); + TEST(XmlRpcValue::makeString("bar", 3).getString() == "bar"); +- TEST(XmlRpcValue::makeString("a\0b").getString() == string("a\0b")); ++ TEST(XmlRpcValue::makeString("a\0b").getString() == std::string("a\0b")); + XmlRpcValue::makeArray().getArray(); + XmlRpcValue::makeStruct().getStruct(); + +@@ -219,7 +219,7 @@ + TEST(strct.structHasKey("bar")); + TEST(!strct.structHasKey("nosuch")); + for (size_t i = 0; i < strct.structSize(); i++) { +- string key; ++ std::string key; + XmlRpcValue value; + strct.structGetKeyAndValue(i, key, value); + TEST(key + "val" == value.getString()); +@@ -248,30 +248,30 @@ + test_errors(); + + } catch (XmlRpcFault& fault) { +- cout << "Unexpected XML-RPC fault when running test suites." << endl ++ std::cout << "Unexpected XML-RPC fault when running test suites." << std::endl + << "Fault #" << fault.getFaultCode() +- << ": " << fault.getFaultString() << endl +- << "FAILED" << endl; ++ << ": " << fault.getFaultString() << std::endl ++ << "FAILED" << std::endl; + exit(1); + } catch (...) { +- cout << "Unexpected exception when running test suites." << endl +- << "FAILED" << endl; ++ std::cout << "Unexpected exception when running test suites." << std::endl ++ << "FAILED" << std::endl; + exit(1); + } + + // Summarize our test run. +- cout << endl << "Ran " << total_tests << " tests, " ++ std::cout << std::endl << "Ran " << total_tests << " tests, " + << total_failures << " failed, " +- << setprecision(4) ++ << std::setprecision(4) + << (100.0 - (100.0 * total_failures) / total_tests) +- << "% passed" << endl; ++ << "% passed" << std::endl; + + // Print the final result. + if (total_failures == 0) { +- cout << "OK" << endl; ++ std::cout << "OK" << std::endl; + return 0; + } + +- cout << "FAILED" << endl; ++ std::cout << "FAILED" << std::endl; + return 1; + } diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::validatee.c net/xmlrpc-c/files/patch-src::validatee.c --- /usr/ports/net/xmlrpc-c/files/patch-src::validatee.c Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-src::validatee.c Tue Mar 2 23:43:23 2004 @@ -0,0 +1,10 @@ +--- src/validatee.c.orig Sat Apr 14 04:04:07 2001 ++++ src/validatee.c Tue Mar 2 23:39:39 2004 +@@ -33,6 +33,7 @@ + + #include + #include ++#include + + #include "xmlrpc.h" + #include "xmlrpc_abyss.h" diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc.h net/xmlrpc-c/files/patch-src::xmlrpc.h --- /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc.h Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-src::xmlrpc.h Tue Mar 2 23:43:47 2004 @@ -0,0 +1,38 @@ +--- src/xmlrpc.h.orig Thu Jun 28 01:35:01 2001 ++++ src/xmlrpc.h Tue Mar 2 23:39:39 2004 +@@ -152,7 +152,7 @@ + + /* The same as the above, but using a printf-style format string. */ + void xmlrpc_env_set_fault_formatted (xmlrpc_env* env, int code, +- char *format, ...); ++ const char *format, ...); + + /* A simple debugging assertion. */ + #define XMLRPC_ASSERT_ENV_OK(env) \ +@@ -362,17 +362,23 @@ + ** Increments the reference counts of input arguments if necessary. + ** See the xmlrpc-c documentation for more information. */ + extern xmlrpc_value * +-xmlrpc_build_value (xmlrpc_env* env, char* format, ...); ++xmlrpc_build_value (xmlrpc_env* env, const char* format, ...); + + /* The same as the above, but using a va_list. */ + extern xmlrpc_value * +-xmlrpc_build_value_va (xmlrpc_env* env, char* format, va_list args); ++xmlrpc_build_value_va (xmlrpc_env* env, const char* format, va_list args); + + /* Extract values from an xmlrpc_value and store them into C variables. + ** Does not increment the reference counts of output values. + ** See the xmlrpc-c documentation for more information. */ + extern void +-xmlrpc_parse_value (xmlrpc_env* env, xmlrpc_value* value, char* format, ...); ++xmlrpc_parse_value (xmlrpc_env* env, xmlrpc_value* value, ++ const char* format, ...); ++ ++/* The same as the above, but using a va_list. */ ++extern void ++xmlrpc_parse_value_va (xmlrpc_env* env, xmlrpc_value* value, ++ const char* format, va_list args); + + /* Return the number of elements in an XML-RPC array. + ** Sets XMLRPC_TYPE_ERROR if 'array' is not an array. */ diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_abyss.c net/xmlrpc-c/files/patch-src::xmlrpc_abyss.c --- /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_abyss.c Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-src::xmlrpc_abyss.c Tue Mar 2 23:44:05 2004 @@ -0,0 +1,10 @@ +--- src/xmlrpc_abyss.c.orig Wed May 2 05:18:48 2001 ++++ src/xmlrpc_abyss.c Tue Mar 2 23:39:39 2004 +@@ -34,6 +34,7 @@ + + #include + #include ++#include + + #include "xmlrpc.h" + diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_data.c net/xmlrpc-c/files/patch-src::xmlrpc_data.c --- /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_data.c Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-src::xmlrpc_data.c Tue Mar 2 23:44:21 2004 @@ -0,0 +1,117 @@ +--- src/xmlrpc_data.c.orig Wed Apr 25 04:20:20 2001 ++++ src/xmlrpc_data.c Tue Mar 2 23:39:39 2004 +@@ -182,10 +182,11 @@ + ** (in theory) also be portable. + */ + +-static xmlrpc_value* mkvalue(xmlrpc_env* env, char** format, va_list* args); ++static xmlrpc_value* mkvalue(xmlrpc_env* env, ++ const char** format, va_list* args); + + static xmlrpc_value* mkarray(xmlrpc_env* env, +- char** format, ++ const char** format, + char delimiter, + va_list* args) + { +@@ -236,7 +237,7 @@ + } + + static xmlrpc_value* mkstruct(xmlrpc_env* env, +- char** format, ++ const char** format, + char delimiter, + va_list* args) + { +@@ -357,7 +358,8 @@ + } + #endif /* HAVE_UNICODE_WCHAR */ + +-static xmlrpc_value* mkvalue(xmlrpc_env* env, char** format, va_list* args) ++static xmlrpc_value* mkvalue(xmlrpc_env* env, ++ const char** format, va_list* args) + { + xmlrpc_value* val; + char *str, *contents; +@@ -497,10 +499,10 @@ + } + + xmlrpc_value* xmlrpc_build_value_va (xmlrpc_env* env, +- char* format, ++ const char* format, + va_list args) + { +- char *format_copy; ++ const char *format_copy; + va_list args_copy; + xmlrpc_value* retval; + +@@ -520,7 +522,7 @@ + } + + xmlrpc_value* xmlrpc_build_value (xmlrpc_env* env, +- char* format, ...) ++ const char* format, ...) + { + va_list args; + xmlrpc_value* retval; +@@ -542,12 +544,12 @@ + + static void parsevalue (xmlrpc_env* env, + xmlrpc_value* val, +- char** format, ++ const char** format, + va_list* args); + + static void parsearray (xmlrpc_env* env, + xmlrpc_value* array, +- char** format, ++ const char** format, + char delimiter, + va_list* args) + { +@@ -584,7 +586,7 @@ + + static void parsestruct(xmlrpc_env* env, + xmlrpc_value* strct, +- char** format, ++ const char** format, + char delimiter, + va_list* args) + { +@@ -633,7 +635,7 @@ + + static void parsevalue (xmlrpc_env* env, + xmlrpc_value* val, +- char** format, ++ const char** format, + va_list* args) + { + xmlrpc_int32 *int32ptr; +@@ -783,12 +785,12 @@ + return; + } + +-static void xmlrpc_parse_value_va (xmlrpc_env* env, +- xmlrpc_value* value, +- char* format, +- va_list args) ++void xmlrpc_parse_value_va (xmlrpc_env* env, ++ xmlrpc_value* value, ++ const char* format, ++ va_list args) + { +- char *format_copy; ++ const char *format_copy; + va_list args_copy; + + XMLRPC_ASSERT_ENV_OK(env); +@@ -808,7 +810,7 @@ + + void xmlrpc_parse_value (xmlrpc_env* env, + xmlrpc_value* value, +- char* format, ...) ++ const char* format, ...) + { + va_list args; + diff -urN /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_support.c net/xmlrpc-c/files/patch-src::xmlrpc_support.c --- /usr/ports/net/xmlrpc-c/files/patch-src::xmlrpc_support.c Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-src::xmlrpc_support.c Tue Mar 2 23:44:38 2004 @@ -0,0 +1,11 @@ +--- src/xmlrpc_support.c.orig Sat Apr 14 03:25:08 2001 ++++ src/xmlrpc_support.c Tue Mar 2 23:39:39 2004 +@@ -99,7 +99,7 @@ + } + + void xmlrpc_env_set_fault_formatted (xmlrpc_env* env, int code, +- char *format, ...) ++ const char *format, ...) + { + va_list args; + char buffer[ERROR_BUFFER_SZ]; diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.cc net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.cc --- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.cc Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.cc Tue Mar 2 23:45:16 2004 @@ -0,0 +1,187 @@ +--- tools/xml-rpc-api2cpp/DataType.cc.orig Fri Mar 30 05:39:06 2001 ++++ tools/xml-rpc-api2cpp/DataType.cc Tue Mar 2 23:39:39 2004 +@@ -1,5 +1,5 @@ +-#include +-#include ++#include ++#include + #include + + #include +@@ -12,12 +12,10 @@ + // Instances of DataType know how generate code fragments for manipulating + // a specific XML-RPC data type. + +-string DataType::defaultParameterBaseName (int position) const { +- ostrstream name_stream; +- name_stream << typeName() << position << ends; +- string name(name_stream.str()); +- // (Ask the ostrstream to reclaim ownership of its buffer.) +- name_stream.freeze(false); ++std::string DataType::defaultParameterBaseName (int position) const { ++ std::ostringstream name_stream; ++ name_stream << typeName() << position << std::ends; ++ std::string name(name_stream.str()); + return name; + } + +@@ -29,27 +27,27 @@ + + class RawDataType : public DataType { + public: +- RawDataType (const string& type_name) : DataType(type_name) {} ++ RawDataType (const std::string& type_name) : DataType(type_name) {} + +- virtual string parameterFragment (const string& base_name) const; +- virtual string inputConversionFragment (const string& base_name) const; +- virtual string returnTypeFragment () const; +- virtual string outputConversionFragment (const string& var_name) const; ++ virtual std::string parameterFragment (const std::string& base_name) const; ++ virtual std::string inputConversionFragment (const std::string& base_name) const; ++ virtual std::string returnTypeFragment () const; ++ virtual std::string outputConversionFragment (const std::string& var_name) const; + }; + +-string RawDataType::parameterFragment (const string& base_name) const { ++std::string RawDataType::parameterFragment (const std::string& base_name) const { + return "XmlRpcValue /*" + typeName() + "*/ " + base_name; + } + +-string RawDataType::inputConversionFragment (const string& base_name) const { ++std::string RawDataType::inputConversionFragment (const std::string& base_name) const { + return base_name; + } + +-string RawDataType::returnTypeFragment () const { ++std::string RawDataType::returnTypeFragment () const { + return "XmlRpcValue /*" + typeName() + "*/"; + } + +-string RawDataType::outputConversionFragment (const string& var_name) const { ++std::string RawDataType::outputConversionFragment (const std::string& var_name) const { + return var_name; + } + +@@ -60,26 +58,26 @@ + // Other types can be easily converted to and from a single native type. + + class SimpleDataType : public DataType { +- string mNativeType; +- string mMakerFunc; +- string mGetterFunc; ++ std::string mNativeType; ++ std::string mMakerFunc; ++ std::string mGetterFunc; + + public: +- SimpleDataType (const string& type_name, +- const string& native_type, +- const string& maker_func, +- const string& getter_func); +- +- virtual string parameterFragment (const string& base_name) const; +- virtual string inputConversionFragment (const string& base_name) const; +- virtual string returnTypeFragment () const; +- virtual string outputConversionFragment (const string& var_name) const; ++ SimpleDataType (const std::string& type_name, ++ const std::string& native_type, ++ const std::string& maker_func, ++ const std::string& getter_func); ++ ++ virtual std::string parameterFragment (const std::string& base_name) const; ++ virtual std::string inputConversionFragment (const std::string& base_name) const; ++ virtual std::string returnTypeFragment () const; ++ virtual std::string outputConversionFragment (const std::string& var_name) const; + }; + +-SimpleDataType::SimpleDataType (const string& type_name, +- const string& native_type, +- const string& maker_func, +- const string& getter_func) ++SimpleDataType::SimpleDataType (const std::string& type_name, ++ const std::string& native_type, ++ const std::string& maker_func, ++ const std::string& getter_func) + : DataType(type_name), + mNativeType(native_type), + mMakerFunc(maker_func), +@@ -87,20 +85,20 @@ + { + } + +-string SimpleDataType::parameterFragment (const string& base_name) const { ++std::string SimpleDataType::parameterFragment (const std::string& base_name) const { + return mNativeType + " " + base_name; + } + +-string SimpleDataType::inputConversionFragment (const string& base_name) const ++std::string SimpleDataType::inputConversionFragment (const std::string& base_name) const + { + return mMakerFunc + "(" + base_name + ")"; + } + +-string SimpleDataType::returnTypeFragment () const { ++std::string SimpleDataType::returnTypeFragment () const { + return mNativeType; + } + +-string SimpleDataType::outputConversionFragment (const string& var_name) const ++std::string SimpleDataType::outputConversionFragment (const std::string& var_name) const + { + return var_name + "." + mGetterFunc + "()"; + } +@@ -116,26 +114,26 @@ + public: + VoidDataType () : DataType("void") {} + +- virtual string parameterFragment (const string& base_name) const; +- virtual string inputConversionFragment (const string& base_name) const; +- virtual string returnTypeFragment () const; +- virtual string outputConversionFragment (const string& var_name) const; ++ virtual std::string parameterFragment (const std::string& base_name) const; ++ virtual std::string inputConversionFragment (const std::string& base_name) const; ++ virtual std::string returnTypeFragment () const; ++ virtual std::string outputConversionFragment (const std::string& var_name) const; + }; + +-string VoidDataType::parameterFragment (const string& base_name) const { +- throw domain_error("Can't handle functions with 'void' arguments'"); ++std::string VoidDataType::parameterFragment (const std::string& base_name) const { ++ throw std::domain_error("Can't handle functions with 'void' arguments'"); + + } + +-string VoidDataType::inputConversionFragment (const string& base_name) const { +- throw domain_error("Can't handle functions with 'void' arguments'"); ++std::string VoidDataType::inputConversionFragment (const std::string& base_name) const { ++ throw std::domain_error("Can't handle functions with 'void' arguments'"); + } + +-string VoidDataType::returnTypeFragment () const { ++std::string VoidDataType::returnTypeFragment () const { + return "void"; + } + +-string VoidDataType::outputConversionFragment (const string& var_name) const { ++std::string VoidDataType::outputConversionFragment (const std::string& var_name) const { + return "/* Return value ignored. */"; + } + +@@ -166,7 +164,7 @@ + + VoidDataType voidType; + +-const DataType& findDataType (const string& name) { ++const DataType& findDataType (const std::string& name) { + if (name == "int" || name == "i4") + return intType; + else if (name == "boolean") +@@ -186,7 +184,7 @@ + else if (name == "void") + return voidType; + else +- throw domain_error("Unknown XML-RPC type " + name); ++ throw std::domain_error("Unknown XML-RPC type " + name); + + // This code should never be executed. + XMLRPC_ASSERT(0); diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.h net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.h --- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.h Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::DataType.h Tue Mar 2 23:45:27 2004 @@ -0,0 +1,40 @@ +--- tools/xml-rpc-api2cpp/DataType.h.orig Mon Mar 26 03:34:53 2001 ++++ tools/xml-rpc-api2cpp/DataType.h Tue Mar 2 23:39:39 2004 +@@ -1,28 +1,28 @@ + + class DataType { +- string mTypeName; ++ std::string mTypeName; + + DataType (const DataType&) { XMLRPC_ASSERT(0); } + DataType& operator= (const DataType&) { XMLRPC_ASSERT(0); return *this; } + + public: +- DataType (const string& type_name) : mTypeName(type_name) {} ++ DataType (const std::string& type_name) : mTypeName(type_name) {} + virtual ~DataType () {} + + // Return the name for this XML-RPC type. +- virtual string typeName () const { return mTypeName; } ++ virtual std::string typeName () const { return mTypeName; } + + // Given a parameter position, calculate a unique base name for all + // parameter-related variables. +- virtual string defaultParameterBaseName (int position) const; ++ virtual std::string defaultParameterBaseName (int position) const; + + // Virtual functions for processing parameters. +- virtual string parameterFragment (const string& base_name) const = 0; +- virtual string inputConversionFragment (const string& base_name) const = 0; ++ virtual std::string parameterFragment (const std::string& base_name) const = 0; ++ virtual std::string inputConversionFragment (const std::string& base_name) const = 0; + + // Virtual functions for processing return values. +- virtual string returnTypeFragment () const = 0; +- virtual string outputConversionFragment (const string& var_name) const = 0; ++ virtual std::string returnTypeFragment () const = 0; ++ virtual std::string outputConversionFragment (const std::string& var_name) const = 0; + }; + +-const DataType& findDataType (const string& name); ++const DataType& findDataType (const std::string& name); diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.cc net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.cc --- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.cc Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.cc Tue Mar 2 23:45:48 2004 @@ -0,0 +1,19 @@ +--- tools/xml-rpc-api2cpp/SystemProxy.cc.orig Mon Mar 26 08:46:28 2001 ++++ tools/xml-rpc-api2cpp/SystemProxy.cc Tue Mar 2 23:39:39 2004 +@@ -10,14 +10,14 @@ + return result; + } + +-XmlRpcValue /*array*/ SystemProxy::methodSignature (string string1) { ++XmlRpcValue /*array*/ SystemProxy::methodSignature (std::string string1) { + XmlRpcValue params = XmlRpcValue::makeArray(); + params.arrayAppendItem(XmlRpcValue::makeString(string1)); + XmlRpcValue result = this->mClient.call("system.methodSignature", params); + return result; + } + +-string SystemProxy::methodHelp (string string1) { ++std::string SystemProxy::methodHelp (std::string string1) { + XmlRpcValue params = XmlRpcValue::makeArray(); + params.arrayAppendItem(XmlRpcValue::makeString(string1)); + XmlRpcValue result = this->mClient.call("system.methodHelp", params); diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.h net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.h --- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.h Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::SystemProxy.h Tue Mar 2 23:45:58 2004 @@ -0,0 +1,28 @@ +--- tools/xml-rpc-api2cpp/SystemProxy.h.orig Mon Mar 26 08:49:56 2001 ++++ tools/xml-rpc-api2cpp/SystemProxy.h Tue Mar 2 23:39:39 2004 +@@ -12,7 +12,7 @@ + public: + SystemProxy (const XmlRpcClient& client) + : mClient(client) {} +- SystemProxy (const string& server_url) ++ SystemProxy (const std::string& server_url) + : mClient(XmlRpcClient(server_url)) {} + SystemProxy (const SystemProxy& o) + : mClient(o.mClient) {} +@@ -29,13 +29,13 @@ + signatures. Each signature is an array of strings. The first item of + each signature is the return type, and any others items are + parameter types. */ +- XmlRpcValue /*array*/ methodSignature (string string1); ++ XmlRpcValue /*array*/ methodSignature (std::string string1); + + /* Given the name of a method, return a help string. */ +- string methodHelp (string string1); ++ std::string methodHelp (std::string string1); + + /* Process an array of calls, and return an array of results. Calls +- should be structs of the form {'methodName': string, 'params': ++ should be structs of the form {'methodName': std::string, 'params': + array}. Each result will either be a single-item array containg the + result value, or a struct of the form {'faultCode': int, + 'faultString': string}. This is useful when you need to make lots of diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.cc net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.cc --- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.cc Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.cc Tue Mar 2 23:46:21 2004 @@ -0,0 +1,81 @@ +--- tools/xml-rpc-api2cpp/XmlRpcClass.cc.orig Mon Mar 26 08:49:19 2001 ++++ tools/xml-rpc-api2cpp/XmlRpcClass.cc Tue Mar 2 23:39:39 2004 +@@ -1,6 +1,6 @@ +-#include ++#include + #include +-#include ++#include + + #include + #include "DataType.h" +@@ -14,7 +14,7 @@ + // This class stores information about a proxy class, and knows how to + // generate code. + +-XmlRpcClass::XmlRpcClass (string class_name) ++XmlRpcClass::XmlRpcClass (std::string class_name) + : mClassName(class_name) + { + } +@@ -39,37 +39,37 @@ + mFunctions.push_back(function); + } + +-void XmlRpcClass::printDeclaration (ostream& out) ++void XmlRpcClass::printDeclaration (std::ostream& out) + { +- cout << "class " << mClassName << " {" << endl; +- cout << " XmlRpcClient mClient;" << endl; +- cout << endl; +- cout << "public:" << endl; +- cout << " " << mClassName << " (const XmlRpcClient& client)" << endl; +- cout << " : mClient(client) {}" << endl; +- cout << " " << mClassName << " (const string& server_url)" << endl; +- cout << " : mClient(XmlRpcClient(server_url)) {}" << endl; +- cout << " " << mClassName << " (const " << mClassName << "& o)" << endl; +- cout << " : mClient(o.mClient) {}" << endl; +- cout << endl; +- cout << " " << mClassName << "& operator= (const " +- << mClassName << "& o) {" << endl; +- cout << " if (this != &o) mClient = o.mClient;" << endl; +- cout << " return *this;" << endl; +- cout << " }" << endl; ++ std::cout << "class " << mClassName << " {" << std::endl; ++ std::cout << " XmlRpcClient mClient;" << std::endl; ++ std::cout << std::endl; ++ std::cout << "public:" << std::endl; ++ std::cout << " " << mClassName << " (const XmlRpcClient& client)" << std::endl; ++ std::cout << " : mClient(client) {}" << std::endl; ++ std::cout << " " << mClassName << " (const std::string& server_url)" << std::endl; ++ std::cout << " : mClient(XmlRpcClient(server_url)) {}" << std::endl; ++ std::cout << " " << mClassName << " (const " << mClassName << "& o)" << std::endl; ++ std::cout << " : mClient(o.mClient) {}" << std::endl; ++ std::cout << std::endl; ++ std::cout << " " << mClassName << "& operator= (const " ++ << mClassName << "& o) {" << std::endl; ++ std::cout << " if (this != &o) mClient = o.mClient;" << std::endl; ++ std::cout << " return *this;" << std::endl; ++ std::cout << " }" << std::endl; + +- vector::iterator f; ++ std::vector::iterator f; + for (f = mFunctions.begin(); f < mFunctions.end(); ++f) { +- f->printDeclarations(cout); ++ f->printDeclarations(std::cout); + } + +- cout << "};" << endl; ++ std::cout << "};" << std::endl; + } + +-void XmlRpcClass::printDefinition (ostream& out) ++void XmlRpcClass::printDefinition (std::ostream& out) + { +- vector::iterator f; ++ std::vector::iterator f; + for (f = mFunctions.begin(); f < mFunctions.end(); ++f) { +- f->printDefinitions(cout, mClassName); ++ f->printDefinitions(std::cout, mClassName); + } + } diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.h net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.h --- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.h Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.h Tue Mar 2 23:46:30 2004 @@ -0,0 +1,29 @@ +--- tools/xml-rpc-api2cpp/XmlRpcClass.h.orig Mon Mar 26 08:43:07 2001 ++++ tools/xml-rpc-api2cpp/XmlRpcClass.h Tue Mar 2 23:39:39 2004 +@@ -1,19 +1,19 @@ +-#include ++#include + + class XmlRpcClass { +- string mClassName; +- vector mFunctions; ++ std::string mClassName; ++ std::vector mFunctions; + + + public: +- XmlRpcClass (string class_name); ++ XmlRpcClass (std::string class_name); + XmlRpcClass (const XmlRpcClass&); + XmlRpcClass& operator= (const XmlRpcClass&); + +- string className () const { return mClassName; } ++ std::string className () const { return mClassName; } + + void addFunction (const XmlRpcFunction& function); + +- void printDeclaration (ostream& out); +- void printDefinition (ostream& out); ++ void printDeclaration (std::ostream& out); ++ void printDefinition (std::ostream& out); + }; diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.cc net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.cc --- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.cc Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.cc Tue Mar 2 23:46:54 2004 @@ -0,0 +1,123 @@ +--- tools/xml-rpc-api2cpp/XmlRpcFunction.cc.orig Mon Mar 26 08:21:07 2001 ++++ tools/xml-rpc-api2cpp/XmlRpcFunction.cc Tue Mar 2 23:39:39 2004 +@@ -1,4 +1,4 @@ +-#include ++#include + #include + + #include +@@ -12,9 +12,9 @@ + // Contains everything we know about a given server function, and knows + // how to print local bindings. + +-XmlRpcFunction::XmlRpcFunction(const string& function_name, +- const string& method_name, +- const string& help, ++XmlRpcFunction::XmlRpcFunction(const std::string& function_name, ++ const std::string& method_name, ++ const std::string& help, + XmlRpcValue synopsis) + : mFunctionName(function_name), mMethodName(method_name), + mHelp(help), mSynopsis(synopsis) +@@ -37,10 +37,10 @@ + return *this; + } + +-void XmlRpcFunction::printDeclarations (ostream& out) { ++void XmlRpcFunction::printDeclarations (std::ostream& out) { + + // XXX - Do a sloppy job of printing documentation. +- out << endl << " /* " << mHelp << " */" << endl; ++ out << std::endl << " /* " << mHelp << " */" << std::endl; + + // Print each declaration. + size_t end = mSynopsis.arraySize(); +@@ -48,16 +48,16 @@ + printDeclaration(out, i); + } + +-void XmlRpcFunction::printDefinitions (ostream& out, const string& className) { ++void XmlRpcFunction::printDefinitions (std::ostream& out, const std::string& className) { + size_t end = mSynopsis.arraySize(); + for (size_t i = 0; i < end; i++) { +- out << endl; ++ out << std::endl; + printDefinition(out, className, i); + } + } + + // Print the parameter declarations. +-void XmlRpcFunction::printParameters (ostream& out, size_t synopsis_index) { ++void XmlRpcFunction::printParameters (std::ostream& out, size_t synopsis_index) { + size_t end = parameterCount(synopsis_index); + bool first = true; + for (size_t i = 0; i < end; i++) { +@@ -67,47 +67,47 @@ + out << ", "; + + const DataType& ptype (parameterType(synopsis_index, i)); +- string basename = ptype.defaultParameterBaseName(i + 1); ++ std::string basename = ptype.defaultParameterBaseName(i + 1); + out << ptype.parameterFragment(basename); + } + } + +-void XmlRpcFunction::printDeclaration (ostream& out, size_t synopsis_index) { ++void XmlRpcFunction::printDeclaration (std::ostream& out, size_t synopsis_index) { + const DataType& rtype (returnType(synopsis_index)); + out << " " << rtype.returnTypeFragment() << " " + << mFunctionName << " ("; + printParameters(out, synopsis_index); +- out << ");" << endl; ++ out << ");" << std::endl; + } + +-void XmlRpcFunction::printDefinition (ostream& out, +- const string& className, ++void XmlRpcFunction::printDefinition (std::ostream& out, ++ const std::string& className, + size_t synopsis_index) + { + const DataType& rtype (returnType(synopsis_index)); + out << rtype.returnTypeFragment() << " " + << className << "::" << mFunctionName << " ("; + printParameters(out, synopsis_index); +- out << ") {" << endl; +- out << " XmlRpcValue params = XmlRpcValue::makeArray();" << endl; ++ out << ") {" << std::endl; ++ out << " XmlRpcValue params = XmlRpcValue::makeArray();" << std::endl; + + /* Emit code to convert the parameters into an array of XML-RPC objects. */ + size_t end = parameterCount(synopsis_index); + for (size_t i = 0; i < end; i++) { + const DataType& ptype (parameterType(synopsis_index, i)); +- string basename = ptype.defaultParameterBaseName(i + 1); ++ std::string basename = ptype.defaultParameterBaseName(i + 1); + out << " params.arrayAppendItem(" +- << ptype.inputConversionFragment(basename) << ");" << endl; ++ << ptype.inputConversionFragment(basename) << ");" << std::endl; + } + + /* Emit the function call.*/ + out << " XmlRpcValue result = this->mClient.call(\"" +- << mMethodName << "\", params);" << endl; ++ << mMethodName << "\", params);" << std::endl; + + /* Emit the return statement. */ + out << " return " << rtype.outputConversionFragment("result") +- << ";" << endl; +- out << "}" << endl; ++ << ";" << std::endl; ++ out << "}" << std::endl; + } + + const DataType& XmlRpcFunction::returnType (size_t synopsis_index) { +@@ -119,7 +119,7 @@ + XmlRpcValue func_synop = mSynopsis.arrayGetItem(synopsis_index); + size_t size = func_synop.arraySize(); + if (size < 1) +- throw domain_error("Synopsis contained no items"); ++ throw std::domain_error("Synopsis contained no items"); + return size - 1; + } + diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.h net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.h --- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.h Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.h Tue Mar 2 23:47:02 2004 @@ -0,0 +1,42 @@ +--- tools/xml-rpc-api2cpp/XmlRpcFunction.h.orig Mon Mar 26 05:17:50 2001 ++++ tools/xml-rpc-api2cpp/XmlRpcFunction.h Tue Mar 2 23:39:39 2004 +@@ -1,27 +1,27 @@ + + class XmlRpcFunction { +- string mFunctionName; +- string mMethodName; +- string mHelp; ++ std::string mFunctionName; ++ std::string mMethodName; ++ std::string mHelp; + XmlRpcValue mSynopsis; + + public: +- XmlRpcFunction(const string& function_name, +- const string& method_name, +- const string& help, ++ XmlRpcFunction(const std::string& function_name, ++ const std::string& method_name, ++ const std::string& help, + XmlRpcValue synopsis); + + XmlRpcFunction (const XmlRpcFunction&); + XmlRpcFunction& operator= (const XmlRpcFunction&); + +- void printDeclarations (ostream& out); +- void printDefinitions (ostream& out, const string& className); ++ void printDeclarations (std::ostream& out); ++ void printDefinitions (std::ostream& out, const std::string& className); + + private: +- void printParameters (ostream& out, size_t synopsis_index); +- void printDeclaration (ostream& out, size_t synopsis_index); +- void printDefinition (ostream& out, +- const string& className, ++ void printParameters (std::ostream& out, size_t synopsis_index); ++ void printDeclaration (std::ostream& out, size_t synopsis_index); ++ void printDefinition (std::ostream& out, ++ const std::string& className, + size_t synopsis_index); + + const DataType& returnType (size_t synopsis_index); diff -urN /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::xml-rpc-api2cpp net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::xml-rpc-api2cpp --- /usr/ports/net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::xml-rpc-api2cpp Thu Jan 1 09:00:00 1970 +++ net/xmlrpc-c/files/patch-tools::xml-rpc-api2cpp::xml-rpc-api2cpp Tue Mar 2 23:47:22 2004 @@ -0,0 +1,170 @@ +--- tools/xml-rpc-api2cpp/xml-rpc-api2cpp.cc.orig Thu Apr 12 08:21:38 2001 ++++ tools/xml-rpc-api2cpp/xml-rpc-api2cpp.cc Tue Mar 2 23:39:39 2004 +@@ -1,4 +1,4 @@ +-#include ++#include + #include + + #include +@@ -17,9 +17,9 @@ + // Connect to a remote server and extract the information we'll need to + // build a proxy class. + +-XmlRpcClass get_class_info (string server_url, +- string class_prefix, +- string class_name) ++XmlRpcClass get_class_info (std::string server_url, ++ std::string class_prefix, ++ std::string class_name) + { + // Create a place to store our data. + XmlRpcClass info(class_name); +@@ -33,22 +33,22 @@ + for (size_t i = 0; i < end; i++) { + + // Break the method name into two pieces. +- string method_prefix; +- string function_name; +- string method_name = methods.arrayGetItem(i).getString(); ++ std::string method_prefix; ++ std::string function_name; ++ std::string method_name = methods.arrayGetItem(i).getString(); + size_t last_dot = method_name.rfind('.'); +- if (last_dot == string::npos) { ++ if (last_dot == std::string::npos) { + function_name = method_name; + } else { +- method_prefix = string(method_name, 0, last_dot); +- function_name = string(method_name, last_dot + 1); ++ method_prefix = std::string(method_name, 0, last_dot); ++ function_name = std::string(method_name, last_dot + 1); + } + + // Decide whether we care about this function. + if (method_prefix == class_prefix) { + + // Fetch some information about the function. +- string help = system.methodHelp(method_name); ++ std::string help = system.methodHelp(method_name); + XmlRpcValue signature = system.methodSignature(method_name); + + // Add this function to our class information. +@@ -66,23 +66,23 @@ + //========================================================================= + // Print a complete header for the specified class. + +-void print_header (ostream& out, XmlRpcClass& class_info) { +- string class_name = class_info.className(); +- out << "// " << class_name << ".h - xmlrpc-c C++ proxy class" << endl; +- out << "// Auto-generated by xml-rpc-api2cpp." << endl; +- out << endl; +- +- string header_symbol = "_" + class_name + "_H_"; +- out << "#ifndef " << header_symbol << endl; +- out << "#define " << header_symbol << " 1" << endl; +- out << endl; +- out << "#include " << endl; +- out << endl; ++void print_header (std::ostream& out, XmlRpcClass& class_info) { ++ std::string class_name = class_info.className(); ++ out << "// " << class_name << ".h - xmlrpc-c C++ proxy class" << std::endl; ++ out << "// Auto-generated by xml-rpc-api2cpp." << std::endl; ++ out << std::endl; ++ ++ std::string header_symbol = "_" + class_name + "_H_"; ++ out << "#ifndef " << header_symbol << std::endl; ++ out << "#define " << header_symbol << " 1" << std::endl; ++ out << std::endl; ++ out << "#include " << std::endl; ++ out << std::endl; + +- class_info.printDeclaration(cout); ++ class_info.printDeclaration(std::cout); + +- out << endl; +- out << "#endif /* " << header_symbol << " */" << endl; ++ out << std::endl; ++ out << "#endif /* " << header_symbol << " */" << std::endl; + } + + +@@ -91,16 +91,16 @@ + //========================================================================= + // Print a complete header for the specified class. + +-void print_cc_file (ostream& out, XmlRpcClass& class_info) { +- string class_name = class_info.className(); +- out << "// " << class_name << ".cc - xmlrpc-c C++ proxy class" << endl; +- out << "// Auto-generated by xml-rpc-api2cpp." << endl; +- out << endl; ++void print_cc_file (std::ostream& out, XmlRpcClass& class_info) { ++ std::string class_name = class_info.className(); ++ out << "// " << class_name << ".cc - xmlrpc-c C++ proxy class" << std::endl; ++ out << "// Auto-generated by xml-rpc-api2cpp." << std::endl; ++ out << std::endl; + +- out << "#include " << endl; +- out << "#include \"" << class_name << ".h\"" << endl; ++ out << "#include " << std::endl; ++ out << "#include \"" << class_name << ".h\"" << std::endl; + +- class_info.printDefinition(cout); ++ class_info.printDefinition(std::cout); + } + + +@@ -113,18 +113,18 @@ + + /* Parse our command-line arguments. */ + if (argc != 4) { +- cerr << argv[0] << ": Usage:" << endl ++ std::cerr << argv[0] << ": Usage:" << std::endl + << " xml-rpc-api2cpp " +- << endl << endl +- << "Sample arguments:" << endl +- << " server_url = http://localhost/RPC2" << endl +- << " method_prefix = system" << endl +- << " local_class = SystemProxy" << endl; ++ << std::endl << std::endl ++ << "Sample arguments:" << std::endl ++ << " server_url = http://localhost/RPC2" << std::endl ++ << " method_prefix = system" << std::endl ++ << " local_class = SystemProxy" << std::endl; + exit(1); + } +- string server_url = argv[1]; +- string method_prefix = argv[2]; +- string local_class = argv[3]; ++ std::string server_url = argv[1]; ++ std::string method_prefix = argv[2]; ++ std::string local_class = argv[3]; + + int status = 0; + XmlRpcClient::Initialize(NAME, VERSION); +@@ -133,18 +133,18 @@ + XmlRpcClass system = get_class_info(server_url, + method_prefix, + local_class); +- print_header(cout, system); +- cout << endl; +- print_cc_file(cout, system); ++ print_header(std::cout, system); ++ std::cout << std::endl; ++ print_cc_file(std::cout, system); + } catch (XmlRpcFault& fault) { +- cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode() +- << ": " << fault.getFaultString() << endl; ++ std::cerr << argv[0] << ": XML-RPC fault #" << fault.getFaultCode() ++ << ": " << fault.getFaultString() << std::endl; + status = 1; +- } catch (logic_error& err) { +- cerr << argv[0] << ": " << err.what() << endl; ++ } catch (std::logic_error& err) { ++ std::cerr << argv[0] << ": " << err.what() << std::endl; + status = 1; + } catch (...) { +- cerr << argv[0] << ": Unknown exception" << endl; ++ std::cerr << argv[0] << ": Unknown exception" << std::endl; + status = 1; + } +