c11n: Check-in [3af1fdf57a]

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview

SHA1 Hash:	3af1fdf57ab1a303c320a0bf103bce5188c1dbd9
Date:	2008-11-13 18:11:40
User:	stephan
Comment:	a number of small cleanups and bug fixes

Changes

hide diffs unified diffs patch

Changes to include/s11n.net/c11n/io/c11n_io.h

--- Old (7601bb59936d7d90)
+++ New (9dbf5d93642321c4)
 #ifndef S11N_NET_C11N_IO_H_INCLUDED
 #define S11N_NET_C11N_IO_H_INCLUDED 1
 /*
    This file contains declarations and documentation for the generic
    i/o routines for c11n. The core does not know about this API and no
 /**
    Tries to register the given (non-0) cookie as a lookup key for
    a factory function which can generate c11n_io_handler objects. On
    success it returns true. It can fail for these reasons:
-   - The number of registration slots is static and quite limited. It can run out.
+   - The number of registration slots is static and quite limited. It
@@ | / 585 / can run out. The library guarantees that at least 10 slots are @@
@@ | / 586 / left open for client-side use, over and above what registrations @@
@@ | / 587 / the library has hard-wired in. @@
    - A different factory was already registered with that name.
    - cookie is 0.
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
 #endif // S11N_NET_C11N_IO_H_INCLUDED

Changes to include/s11n.net/c11n/io/c11n_io_handler_expat.h

--- Old (325d453e3ac3c316)
+++ New (fc528579da23b3cc)
 #if !defined(_S11N_NET_C11N_IO_HANDLER_EXPAT_H_INCLUDED_)
 #define _S11N_NET_C11N_IO_HANDLER_EXPAT_H_INCLUDED_ 1
 #include "c11n_io.h"
 #ifdef __cplusplus
    Compat mode is turned off by default because it is possible (and
    more efficient) to use the "binarish" format to convert data
    between libs11n and libc11n.
 */
-#define C11N_IO_HANDLER_EXPAT_S11N_COMPAT 0
+#define C11N_IO_HANDLER_EXPAT_S11N_COMPAT 1
 /** @def C11N_IO_HANDLER_EXPAT_COOKIE
     Unfortunately C11N_IO_HANDLER_EXPAT_COOKIE must be defined as a macro
     instead of a (extern char const *) because C won't allow non-const
     initializers and we may use this cookie in static registration code.
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
 #endif /* _S11N_NET_C11N_IO_HANDLER_EXPAT_H_INCLUDED_ */

Changes to src/c11n_io_handler_binarish.c

--- Old (a15017b2225be2d6)
+++ New (253bb514b07d1350)
 #include "s11n.net/c11n/io/c11n_io.h"
 #include "s11n.net/c11n/detail/whclob.h"
 #include <stdlib.h>
 #include <ctype.h> /* isspace() and friends. */
 */
 static bool binarish_read_token(c11n_io_handler * self, size_t size, bool skipWS )
+{
     IMPLDECL(false);
     if( !self || (0 == size) ) return false;
-#if 0
+#if 1
@@ | / 302 / /* @@
@@ | / 303 / This requires much fewer allocs than whclob_reset(), though it @@
@@ | / 304 / also means that impl->clob will stay the size of the largest @@
@@ | / 305 / token throughout the parse process. @@
@@ | / 306 / */ @@
     whclob_reserve( impl->clob, size ? size : 1 );
-    whclob_truncate( impl->clob, 0, 1 );
+    whclob_truncate( impl->clob, 0, 0 );
 #else
     whclob_reset(impl->clob);
     whclob_reserve( impl->clob, size );
 #endif
     char * buf = whclob_buffer(impl->clob);
 c11n_io_handler * c11n_io_handler_factory_binarish( c11n_const_string_t ignored )
+{
     return c11n_io_handler_create_binarish();
+}

Changes to src/c11n_io_handler_expat.c

--- Old (857a85d9653cb677)
+++ New (735eeeee89d7518e)
 #include "s11n.net/c11n/io/c11n_io.h"
 #include "s11n.net/c11n/io/c11n_io_handler_expat.h"
 #include "s11n.net/c11n/detail/whclob.h"
 #include <stdlib.h>
 {"<",1,"&lt;",4},
 {">",1,"&gt;",4},
 #if C11N_IO_HANDLER_EXPAT_S11N_COMPAT
 /**
    The next two would be here only here to accomodate an old mistake in
-   libs11n's expat format (with which we may want to be compatible here):
+   libs11n's expat format (with which we want to be compatible here).
-*/
+   In theory we don't need them - expat does the unescaping for us, so libs11n
@@ | / 62 / should be able to cope with unescaped quotes. @@
@@ | / 63 @@
 {"\"",1,"&quot;",6},
 {"'",1,"&apos;",6},
+*/
 #endif
 {0,0,0,0}
 };
     c11n_stream * dest = impl->stream;
     if( impl->indentLevel++ != 0 )
+    {
 	whclob_append( impl->tabs, "\t", 1 );
+	//whclob_null_terminate( impl->tabs );
+    }
     char const * tabs = whclob_bufferc( impl->tabs );
+    if( ! tabs || !*tabs ) tabs = "";
@@ > / 99 @@
     WF( dest, "%s<%s class=\"%s\">\n", tabs, c11n_node_get_name( src ), c11n_node_get_class(src) );
 #if 1
     c11n_prop_iter piter = c11n_node_prop_iter(src);
     while( c11n_prop_iter_isvalid( &piter ) )
+    {
 	whclob_truncate( impl->xlate, 0, 0 );
 	if( val )
+	{
 	    c11n_io_escape_string( val, c11n_strlen( val ), expat_val_escapes, true, impl->xlate );
+	}
-	WF( dest, "%s\t<%s>%s</%s>\n", tabs, key,
+	WF( dest, "\t%s<%s>%s</%s>\n", tabs, key,
 	    whclob_size(impl->xlate) ? whclob_bufferc(impl->xlate) : "",
 	    key );
 	c11n_prop_iter_next(&piter);
+    }
 #endif
+    {
 	if( ! expat_save_node( self, chi.node ) ) return false;
 	c11n_node_iter_next_c(&chi);
+    }
 #endif
+    --impl->indentLevel;
+    whclob_truncate( impl->tabs, impl->indentLevel, 0 );
     WF( dest, "%s</%s>\n", tabs, c11n_node_get_name( src ) );
 #undef WF
 #undef W
-    whclob_resize( impl->tabs, --impl->indentLevel );
+    //whclob_null_terminate( impl->tabs );
     return true;
+}
 static bool expat_save_root_node( c11n_io_handler * self,
 				  c11n_node const * src,
     IMPLDECL(false);
     if( !src || (!dest || !dest->api->isgood(dest)) ) return false;
     if(0) return expat_save_root_node(self,src,dest);/* kludge to avoid "static func defined but not used" warning*/
     self->api->clear(self);
     impl->stream = dest;
-#define WF c11n_stream_writef
-#define LEN(S) c11n_strlen(S)
@@ 138 / < @@
     impl->tabs = whclob_new();
     impl->xlate = whclob_new();
-    WF( dest, "%s\n", self->api->cookie_string );
+    c11n_stream_writef( dest, "%s\n", self->api->cookie_string );
     bool ret =  expat_save_node( self, src );
     self->api->clear(self);
-#undef LEN
-#undef WF
     return ret;
+}
 #define XSELFDECL c11n_io_expat_data * impl = (c11n_io_expat_data *)uArg; assert(impl && "impl failed!"); if(!impl) return
 c11n_io_handler * c11n_io_handler_factory_expat( c11n_const_string_t ignored )
+{
     return c11n_io_handler_create_expat();
+}

Changes to src/c11n_io_handler_sql.c

--- Old (8d436283c0bcbe1c)
+++ New (f6ec0e47e47cda19)
 #include <stdlib.h> /* malloc()/free() */
 #include <sqlite3.h>
 #include <assert.h>
 #include "s11n.net/c11n/io/c11n_io_handler_sql.h"
 #include "s11n.net/c11n/io/c11n_stream_whclob.h"
+{
 #define PUL(X) ((unsigned long)(X))
     c11n_node const * par = c11n_node_parent_c( src );
     /**
        Maybe todo: replace the %Q writef specifiers with
-       c11n_io_escape_string().  %Q is an extension of vappendf(),
+       c11n_io_escape_string(). %Q is an extension of vappendf(),
        inherited from the sqlite3 origins of vappendf()'s
        implementation.
     */
     c11n_stream_writef( dest,
 			"INSERT INTO n (id,pid,name,class) "
 				      c11n_prop_iter_key( &piter ),
 				      c11n_prop_iter_val( &piter ) );
 	if( ! rc ) return false;
 	c11n_prop_iter_next(&piter);
+    }
-#undef PUL /* i sometimes find it interesting that even though macros do not respect scope, we programmers tend to respect it when defining/undefining macros. */
+#undef PUL /* i sometimes find it interesting that even though macros
@@ | / 313 / do not respect scope, we programmers tend to respect @@
@@ | / 314 / scopes when defining/undefining macros. */ @@
     c11n_node_iter_c chi = c11n_node_children_iter_c( src );
     while( c11n_node_iter_isvalid_c( &chi ) )
+    {
 	if( ! c11n_io_handler_sql_save_one_node( self, chi.node, dest ) ) return false;
 	c11n_node_iter_next_c(&chi);
 c11n_io_handler * c11n_io_handler_factory_sql( c11n_const_string_t ignored )
+{
     return c11n_io_handler_sql_new();
+}

Changes to src/c11nconvert.c

--- Old (556642b4ed472aef)
+++ New (8470a76984a6c793)
 #include "s11n.net/c11n/c11n.h"
 #include "s11n.net/c11n/io/c11n_io.h"
 #include "s11n.net/c11n/io/c11n_stream_FILE.h"
 #include <stdio.h>
+    {
 	ERROR("Could not read c11n_node from stdin!");
 	return ErrIO;
+    }
     whgc_add( ThisApp.gc, nodeIn, gc_c11n_node );
     //c11n_dump_node( nodeIn, true );
     if( ! writer->api->save_node( writer, nodeIn, outStream ) )
+    {
 	ERROR("Save failed!");
 	return ErrIO;
 		 (0==rc)
 		 ? "You win :)"
 		 : "You lose :(");
     return rc;
+}

Changes to src/test.c

--- Old (879583fb44743ad1)
+++ New (9063e71e1dcb9858)
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <assert.h>
     //whclob_finalize(cb);
     return 0;
+}
 #if C11N_IO_USE_SQL
-#include "s11n.net/c11n/io/c11n_io_handler_sql.h"
 int test_sql()
+{
-    c11n_io_handler * ioh = c11n_io_handler_for_sql();
+    c11n_io_handler * ioh =
@@ | / 463 / //c11n_io_handler_by_name("binarish") @@
@@ | / 464 / c11n_io_handler_by_name("sql") @@
@@ | / 465 / ; @@
     MARKER("ioh @ %p\n",ioh);
     c11n_io_tree_builder bob = c11n_io_tree_builder_init;
     bob.open_node( &bob, "myNode", "SumDumType" );
     bob.set_prop( &bob, "foo", "donkey ears" );
 	   : "You lose :(");
     ThisApp.cout->api->destroy(ThisApp.cout);
     whgc_destroy_context(ThisApp.gc);
     return rc;
+}

Changes to src/whclob.c

--- Old (bf41c0a532db1e43)
+++ New (7a37db85b2a5c1fc)
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 static long whclob_do_resize( whclob * cb,
 			      unsigned int sz,
 			      short usePolicyHint)
+{
-    static const int fudge = 1;
+    static const int fudge = 2;
     char const * zOld = 0;
     long oldUsed = 0;
     long oldAlloc = 0;
     long allocsize = 0;
     char * pNew = 0;
 long whclob_append( whclob * cb, char const * data, long dsize )
+{
 	long old = cb->nUsed;
-	cb->nUsed += whclob_writeat( cb, cb->nUsed, data, dsize );
+	long rc = whclob_writeat( cb, cb->nUsed, data, dsize );
@@ | / 467 / if( rc < whclob_rc.OK ) return rc; @@
@@ | / 468 / cb->nUsed += rc; @@
@@ | / 469 / //cb->aData[cb->nUsed] = 0; @@
@@ | / 470 / whclob_null_terminate(cb); @@
 	return cb->nUsed - old;
+}
 long whclob_append_char_n( whclob * cb, char c, long n )
+{
     if( !cb || (n <= 0) ) return whclob_rc.RangeError;
     rc = whclob_reserve( cb, cb->nUsed + n );
     if( rc < 0 ) return rc;
     memset( cb->aData + cb->nUsed, c, n );
     cb->nUsed += n;
+    /* do we want to do a whclob_null_terminate() here? */
+    /* whclob_null_terminate(cb); */
     return n;
+}
 long whclob_copy( whclob * src, whclob * dest )
+}
 #endif /* WHCLOB_USE_FILE */
 #undef WHCLOB_USE_ZLIB
 #undef WHCLOB_DEBUG