rebase advanced branch to current trunk - Release 1.22.00

git-svn-id: https://xmlrpc-c.svn.sourceforge.net/svnroot/xmlrpc-c/advanced@1901 adbb7d4b-a73a-0410-a071-c5f57c452bd4

Author: giraffedata

GNUmakefile

@@ -83,7 +83,7 @@ version.h: $(SRCDIR)/version.mk
 	echo "#define XMLRPC_VERSION_MINOR $(MINOR)" >>$@
 	echo "#define XMLRPC_VERSION_POINT $(POINT)" >>$@
 
-include transport_config.make
+include transport_config.mk
 
 # shell_config is a fragment to place inside a Bourne shell program that
 # sets variables that tell how the build is configured.

Windows/xmlrpc_win32_config.h

@@ -180,6 +180,20 @@
 */
 #pragma warning(disable:4996)
 #endif
+/* Warning C4090 is "different 'const' qualifiers".
+
+   We disable this warning because MSVC erroneously issues it when there is
+   in fact no difference in const qualifiers:
+
+     const char ** p;
+     void * q;
+     q = p;
+
+   Note that both p and q are pointers to non-const.
+
+   We have seen this in MSVC 7.1, 8, and 9 (but not 6).
+*/
+#pragma warning(disable:4090)
 
 #if HAVE_STRTOLL
   # define XMLRPC_STRTOLL strtoll

common.mk

@@ -98,19 +98,19 @@ $(TARGET_STATIC_LIBRARIES):
 ##############################################################################
 
 ifeq ($(SHARED_LIB_TYPE),unix)
-  include $(SRCDIR)/unix-common.make
+  include $(SRCDIR)/unix-common.mk
   endif
 
 ifeq ($(SHARED_LIB_TYPE),irix)
-  include $(SRCDIR)/irix-common.make
+  include $(SRCDIR)/irix-common.mk
   endif
 
 ifeq ($(SHARED_LIB_TYPE),dll)
-  include $(SRCDIR)/dll-common.make
+  include $(SRCDIR)/dll-common.mk
   endif
 
 ifeq ($(SHARED_LIB_TYPE),dylib)
-  include $(SRCDIR)/dylib-common.make
+  include $(SRCDIR)/dylib-common.mk
   endif
 
 ifeq ($(SHARED_LIB_TYPE),NONE)

config.mk.in

@@ -326,12 +326,12 @@ endif
 ##############################################################################
 
 # BUILDTOOL_CC is the compiler to use to generate build tools, which we
-# will then run to build product.  The typical reason this would be
+# will then run to build the product.  The typical reason this would be
 # different from CC is that you're cross-compiling: the product will run
 # in Environment A, but you're building in Environment B, so you must
-# build the build toos for Environment B.
+# build the build tools for Environment B.
 
-# The cross compiling user can update Makefile.config or override
+# The cross compiling user can update config.mk or override
 # BUILDTOOL_CC on a make command.
 
 BUILDTOOL_CC = $(CC)

dll-common.make renamed to dll-common.mk

@@ -1,7 +1,7 @@
 # -*-makefile-*-    <-- an Emacs control
 
-# See unix-common.make for an explanation of this file.  This file is
-# analogous to unix-common.make, but is for a Windows system
+# See unix-common.mk for an explanation of this file.  This file is
+# analogous to unix-common.mk, but is for a Windows system
 
 SONAME = $@
 IMPLIB = $(@:%:%.dll.a)

doc/INSTALL

@@ -82,6 +82,44 @@ you have to have a -f option and set SRCDIR and BLDDIR on your 'make'
 command.
 
 
+CROSS-COMPILING
+---------------
+
+Cross compiling is building code on one machine to be run on another,
+particularly when the two machines are different enough that it matters,
+e.g. one executes x86 instructions and the other executes PowerPC
+instructions.
+
+The machine that will run the code is called the target machine.  The one
+that will build the code is the build machine.
+
+To cross-compile, you set up nearly all of the build environment for the
+target machine (that includes such things as the default include file search
+path for the compiler and library search path for the linker).  On your
+'configure' command, you use a --host option to identify the kind of target
+machine (rather than let it default to the kind of machine on which
+'configure' is running).  It's a nontrivial task, and beyond the scope of
+this document as it is not specific to Xmlrpc-c.
+
+There is one area that requires special attention and is specific to Xmlrpc-c:
+The Xmlrpc-c build does part of its job by compiling a program from C source
+code and running that program as part of the build.  That compile, unlike all
+the regular ones, must be done for the build machine, not the target
+machine.
+
+To facilitate that, there are the BUILDTOOL_CC and BUILDTOOL_CCLD make
+variables.  BUILDTOOL_CC is the command name for the appropriate compiler
+which which to build a build tool, i.e. a compiler that generates code to run
+on the build system.  BUILDTOOL_CCLD is similarly for the linker, and should
+be the kind of linker command that invokes a combined compiler/linker,
+e.g. "gcc" instead of "ld".
+
+You can set these make variables on the Make command line, or if you prefer,
+by modifying the file 'config.mk' after 'configure' creates it.  The default
+value of these variables (as set in 'config.mk') is the same compile and link
+commands as for building target code.
+
+
 COMMON PROBLEMS
 ---------------
 

dylib-common.make renamed to dylib-common.mk

@@ -1,7 +1,7 @@
 # -*-makefile-*-    <-- an Emacs control
 
-# See unix-common.make for an explanation of this file.  This file is
-# analogous to unix-common.make, but is for an Irix system.
+# See unix-common.mk for an explanation of this file.  This file is
+# analogous to unix-common.mk, but is for an Irix system.
 
 SONAME = $(@:%.$(MIN)=%)
 

examples/Makefile

@@ -44,15 +44,19 @@ SERVERPROGS_ABYSS = \
   xmlrpc_sample_add_server \
   xmlrpc_server_validatee \
 
+BASIC_PROGS = \
+  json \
+  gen_sample_add_xml \
+
 # Build up PROGS:
 PROGS = 
 
+PROGS += $(BASIC_PROGS)
+
 ifeq ($(ENABLE_ABYSS_SERVER),yes)
   PROGS += $(SERVERPROGS_ABYSS)
 endif
 
-PROGS += gen_sample_add_xml
-
 ifeq ($(MUST_BUILD_CLIENT),yes)
   PROGS += $(CLIENTPROGS)
 endif
@@ -98,9 +102,10 @@ $(SERVERPROGS_CGI):%.cgi:%_cgi.o
 $(SERVERPROGS_ABYSS):%:%.o
 	$(CCLD) -o $@ $^ $(LIBS_SERVER_ABYSS) $(LDFLAGS)
 
-gen_sample_add_xml:%:%.o
+$(BASIC_PROGS):%:%.o
 	$(CCLD) -o $@ $^ $(LIBS_BASE) $(LDFLAGS) 
 
+
 OBJECTS = $(patsubst %,%.o,$(patsubst %.cgi,%_cgi,$(PROGS)))
 
 $(OBJECTS):%.o:%.c

examples/json.c

@@ -0,0 +1,110 @@
+/* 
+  This example program demonstrates the JSON parsing and generating
+  capabilities of Xmlrpc-c.
+
+  The program reads JSON text from Standard Input and displays its value as
+  XML-RPC XML text.  It then re-generates JSON from the intermediate
+  parsed information and displays that.
+*/
+#include <stdio.h>
+
+#include <xmlrpc-c/json.h>
+
+
+
+static void 
+dieIfFaultOccurred(xmlrpc_env * const envP) {
+    if (envP->fault_occurred) {
+        fprintf(stderr, "ERROR: %s (%d)\n",
+                envP->fault_string, envP->fault_code);
+        exit(1);
+    }
+}
+
+
+
+void
+printAsXml(xmlrpc_value * const valP) {
+
+    xmlrpc_env env;
+    xmlrpc_mem_block out;
+
+    xmlrpc_env_init(&env);
+    
+    XMLRPC_MEMBLOCK_INIT(char, &env, &out, 0);
+
+    dieIfFaultOccurred(&env);
+
+    xmlrpc_serialize_value(&env, &out, valP);
+
+    printf("XML-RPC XML:\n");
+
+    printf("%s\n", XMLRPC_MEMBLOCK_CONTENTS(char, &out));
+
+    XMLRPC_MEMBLOCK_CLEAN(char, &out);
+    xmlrpc_env_clean(&env);
+}
+
+
+
+void
+printAsJson(xmlrpc_value * const valP) {
+
+    xmlrpc_env env;
+    xmlrpc_mem_block out;
+    xmlrpc_value * val2P;
+
+    xmlrpc_env_init(&env);
+
+    XMLRPC_MEMBLOCK_INIT(char, &env, &out, 0);
+
+    dieIfFaultOccurred(&env);
+
+    xmlrpc_serialize_json(&env, valP, &out);
+
+    dieIfFaultOccurred(&env);
+
+    printf("JSON:\n");
+
+    printf("%s\n", XMLRPC_MEMBLOCK_CONTENTS(char, &out));
+
+    XMLRPC_MEMBLOCK_CLEAN(char, &out);
+    xmlrpc_env_clean(&env);
+}
+
+
+
+int
+main(int argc, const char *argv[]) {
+
+    xmlrpc_env env;
+    char buf[1024];
+    xmlrpc_value * valP;
+    size_t bytesRead;
+
+    xmlrpc_env_init(&env);
+
+    if (argc-1 > 0) {
+        fprintf(stderr, "This program has no arguments.  "
+                "JSON input is from Standard Input\n");
+        exit(1);
+    }
+    
+    bytesRead = fread(buf, 1, sizeof(buf), stdin);
+    buf[bytesRead] = '\0';
+        
+    valP = xmlrpc_parse_json(&env, buf);
+
+    dieIfFaultOccurred(&env);
+
+    printAsXml(valP);
+
+    printAsJson(valP);
+
+    xmlrpc_DECREF(valP);
+    xmlrpc_env_clean(&env);
+    
+    return 0;
+}
+
+

examples/xmlrpc_loop_server.c

@@ -1,6 +1,8 @@
 /* A simple standalone XML-RPC server based on Abyss that contains a
    simple one-thread request processing loop.  
 
+   This uses the "provide your own Abyss server" mode of operation.
+
    xmlrpc_sample_add_server.c is a server that does the same thing, but
    does it by running a full Abyss daemon in the background, so it has
    less control over how the requests are served.

examples/xmlrpc_sample_add_client.c

@@ -16,9 +16,9 @@
 #define VERSION "1.0"
 
 static void 
-die_if_fault_occurred (xmlrpc_env * const envP) {
+dieIfFaultOccurred (xmlrpc_env * const envP) {
     if (envP->fault_occurred) {
-        fprintf(stderr, "XML-RPC Fault: %s (%d)\n",
+        fprintf(stderr, "ERROR: %s (%d)\n",
                 envP->fault_string, envP->fault_code);
         exit(1);
     }
@@ -46,7 +46,7 @@ main(int           const argc,
 
     /* Start up our XML-RPC client library. */
     xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
-    die_if_fault_occurred(&env);
+    dieIfFaultOccurred(&env);
 
     printf("Making XMLRPC call to server url '%s' method '%s' "
            "to request the sum "
@@ -55,11 +55,11 @@ main(int           const argc,
     /* Make the remote procedure call */
     resultP = xmlrpc_client_call(&env, serverUrl, methodName,
                                  "(ii)", (xmlrpc_int32) 5, (xmlrpc_int32) 7);
-    die_if_fault_occurred(&env);
+    dieIfFaultOccurred(&env);
 
     /* Get our sum and print it out. */
     xmlrpc_read_int(&env, resultP, &sum);
-    die_if_fault_occurred(&env);
+    dieIfFaultOccurred(&env);
     printf("The sum is %d\n", sum);
 
     /* Dispose of our result value. */