Date: Thu, 4 Mar 2004 21:01:55 +0900 From: KATO Tsuguru <tkato@prontomail.com> To: FreeBSD-gnats-submit@FreeBSD.org Subject: ports/63752: Update port: net/xmlrpc-c Message-ID: <20040304210155.036d429b.tkato@prontomail.com> Resent-Message-ID: <200403041210.i24CABGI092825@freefall.freebsd.org>
next in thread | raw e-mail | index | archive | help
>Number: 63752
>Category: ports
>Synopsis: Update port: net/xmlrpc-c
>Confidential: no
>Severity: non-critical
>Priority: low
>Responsible: freebsd-ports-bugs
>State: open
>Quarter:
>Keywords:
>Date-Required:
>Class: change-request
>Submitter-Id: current-users
>Arrival-Date: Thu Mar 04 04:10:11 PST 2004
>Closed-Date:
>Last-Modified:
>Originator: KATO Tsuguru
>Release: FreeBSD 4.9-RELEASE-p3 i386
>Organization:
>Environment:
>Description:
- Fix build on -current
New file:
files/patch-examples::interop-client::InteropEchoProxy.cc
files/patch-examples::interop-client::InteropEchoProxy.h
files/patch-examples::interop-client::interop-client.cc
files/patch-examples::meerkat-app-list.cc
files/patch-src::XmlRpcCpp.cc
files/patch-src::XmlRpcCpp.h
files/patch-src::cpptest.cc
files/patch-src::validatee.c
files/patch-src::xmlrpc.h
files/patch-src::xmlrpc_abyss.c
files/patch-src::xmlrpc_data.c
files/patch-src::xmlrpc_support.c
files/patch-tools::xml-rpc-api2cpp::DataType.cc
files/patch-tools::xml-rpc-api2cpp::DataType.h
files/patch-tools::xml-rpc-api2cpp::SystemProxy.cc
files/patch-tools::xml-rpc-api2cpp::SystemProxy.h
files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.cc
files/patch-tools::xml-rpc-api2cpp::XmlRpcClass.h
files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.cc
files/patch-tools::xml-rpc-api2cpp::XmlRpcFucntion.h
files/patch-tools::xml-rpc-api2cpp::xml-rpc-api2cpp
Remove file:
files/patch-src-XmlRpcCpp.h
>How-To-Repeat:
>Fix:
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 <bsd.port.pre.mk>
-
-pre-patch:
- @${REINPLACE_CMD} -e 's,<malloc.h>,<stdlib.h>,' \
- ${WRKSRC}/lib/abyss/src/data.c \
- ${WRKSRC}/tools/turbocharger/mod_gzip.c
- cd ${WRKSRC}; ${REINPLACE_CMD} -e 's,<strstream.h>,<strstream>,' \
- examples/meerkat-app-list.cc \
- tools/xml-rpc-api2cpp/DataType.cc
-
-post-install:
- @${RM} -f ${PREFIX}/lib/*.la
-
-.include <bsd.port.post.mk>
+.include <bsd.port.mk>
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 <XmlRpcCpp.h>
+ #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 <iostream.h>
+-#include <fstream.h>
++#include <iostream>
++#include <fstream>
+ #include <stdexcept>
+
+ #include <XmlRpcCpp.h>
+@@ -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 <server-url-file> <output-html-file>";
+- cerr << endl;
++ std::cerr << "Usage: interop-client <server-url-file> <output-html-file>";
++ 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 <iostream.h>
+-#include <strstream.h>
++#include <iostream>
++#include <sstream>
+
+ #include <XmlRpcCpp.h>
+
+@@ -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 <http://www.oreillynet.com/meerkat/>." << endl;
++ std::cerr << "Usage: meekat-app-list [hours]" << std::endl;
++ std::cerr << "Data from <http://www.oreillynet.com/meerkat/>." << 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 <string>
--// using namespace std;
-
- #include <xmlrpc.h>
- #include <xmlrpc_client.h>
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<char*>(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<char*>(appname.c_str()),
+ const_cast<char*>(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 <stdio.h>
+ #include <stdlib.h>
++#include <string.h>
+
+ #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 <stdio.h>
+ #include <stdlib.h>
++#include <string.h>
+
+ #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 <iostream.h>
+-#include <strstream.h>
++#include <iostream>
++#include <sstream>
+ #include <stdexcept>
+
+ #include <XmlRpcCpp.h>
+@@ -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 <iostream.h>
++#include <iostream>
+ #include <stdexcept>
+-#include <vector.h>
++#include <vector>
+
+ #include <XmlRpcCpp.h>
+ #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<XmlRpcFunction>::iterator f;
++ std::vector<XmlRpcFunction>::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<XmlRpcFunction>::iterator f;
++ std::vector<XmlRpcFunction>::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 <vector.h>
++#include <vector>
+
+ class XmlRpcClass {
+- string mClassName;
+- vector<XmlRpcFunction> mFunctions;
++ std::string mClassName;
++ std::vector<XmlRpcFunction> 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 <iostream.h>
++#include <iostream>
+ #include <stdexcept>
+
+ #include <XmlRpcCpp.h>
+@@ -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 <iostream.h>
++#include <iostream>
+ #include <stdexcept>
+
+ #include <XmlRpcCpp.h>
+@@ -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 <XmlRpcCpp.h>" << 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 <XmlRpcCpp.h>" << 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 <XmlRpcCpp.h>" << endl;
+- out << "#include \"" << class_name << ".h\"" << endl;
++ out << "#include <XmlRpcCpp.h>" << 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 <server_url> <method_prefix> <local_class>"
+- << 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;
+ }
+
>Release-Note:
>Audit-Trail:
>Unformatted:
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?20040304210155.036d429b.tkato>