src/libopensrf/osrf_json_object.c

   1 /*
   2 Copyright (C) 2006  Georgia Public Library Service
   3 Bill Erickson <billserickson@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14 */
  15
  16 #include <stdlib.h>
  17 #include <ctype.h>
  18 #include <errno.h>
  19 #include <limits.h>
  20 #include <opensrf/log.h>
  21 #include <opensrf/osrf_json.h>
  22 #include <opensrf/osrf_json_utils.h>
  23
  24 /* cleans up an object if it is morphing another object, also
  25  * verifies that the appropriate storage container exists where appropriate */
  26 #define JSON_INIT_CLEAR(_obj_, newtype)         \
  27         if( _obj_->type == JSON_HASH && newtype != JSON_HASH ) {                        \
  28                 osrfHashFree(_obj_->value.h);                   \
  29                 _obj_->value.h = NULL;                                  \
  30 } else if( _obj_->type == JSON_ARRAY && newtype != JSON_ARRAY ) {       \
  31                 osrfListFree(_obj_->value.l);                   \
  32                 _obj_->value.l = NULL;                                  \
  33 } else if( _obj_->type == JSON_STRING || _obj_->type == JSON_NUMBER ) { \
  34                 free(_obj_->value.s);                                           \
  35                 _obj_->value.s = NULL;                                  \
  36 } \
  37         _obj_->type = newtype;\
  38         if( newtype == JSON_HASH && _obj_->value.h == NULL ) {  \
  39                 _obj_->value.h = osrfNewHash();         \
  40                 osrfHashSetCallback( _obj_->value.h, _jsonFreeHashItem ); \
  41 } else if( newtype == JSON_ARRAY && _obj_->value.l == NULL ) {  \
  42                 _obj_->value.l = osrfNewList();         \
  43                 _obj_->value.l->freeItem = _jsonFreeListItem;\
  44 }
  45
  46 static int unusedObjCapture = 0;
  47 static int unusedObjRelease = 0;
  48 static int mallocObjCreate = 0;
  49 static int currentListLen = 0;
  50
  51 union unusedObjUnion{
  52
  53         union unusedObjUnion* next;
  54         jsonObject obj;
  55 };
  56 typedef union unusedObjUnion unusedObj;
  57
  58 // We maintain a free list of jsonObjects that are available
  59 // for use, in order to reduce the churning through
  60 // malloc() and free().
  61
  62 static unusedObj* freeObjList = NULL;
  63
  64 static void add_json_to_buffer( const jsonObject* obj, growing_buffer * buf );
  65
  66 /**
  67  * Return all unused jsonObjects to the heap
  68  * @return Nothing
  69  */
  70 void jsonObjectFreeUnused( void ) {
  71
  72         unusedObj* temp;
  73         while( freeObjList ) {
  74                 temp = freeObjList->next;
  75                 free( freeObjList );
  76                 freeObjList = temp;
  77         }
  78 }
  79
  80 jsonObject* jsonNewObject(const char* data) {
  81
  82         jsonObject* o;
  83
  84         if( freeObjList ) {
  85                 o = (jsonObject*) freeObjList;
  86                 freeObjList = freeObjList->next;
  87         unusedObjRelease++;
  88         currentListLen--;
  89         } else {
  90                 OSRF_MALLOC( o, sizeof(jsonObject) );
  91         mallocObjCreate++;
  92     }
  93
  94         o->size = 0;
  95         o->classname = NULL;
  96         o->parent = NULL;
  97
  98         if(data) {
  99                 o->type = JSON_STRING;
 100                 o->value.s = strdup(data);
 101         } else {
 102                 o->type = JSON_NULL;
 103                 o->value.s = NULL;
 104         }
 105
 106         return o;
 107 }
 108
 109 jsonObject* jsonNewObjectFmt(const char* data, ...) {
 110
 111         jsonObject* o;
 112
 113         if( freeObjList ) {
 114                 o = (jsonObject*) freeObjList;
 115                 freeObjList = freeObjList->next;
 116         unusedObjRelease++;
 117         currentListLen--;
 118         } else {
 119                 OSRF_MALLOC( o, sizeof(jsonObject) );
 120         mallocObjCreate++;
 121     }
 122
 123         o->size = 0;
 124         o->classname = NULL;
 125         o->parent = NULL;
 126
 127         if(data) {
 128                 VA_LIST_TO_STRING(data);
 129                 o->type = JSON_STRING;
 130                 o->value.s = strdup(VA_BUF);
 131         }
 132         else {
 133                 o->type = JSON_NULL;
 134                 o->value.s = NULL;
 135         }
 136
 137         return o;
 138 }
 139
 140 jsonObject* jsonNewNumberObject( double num ) {
 141         jsonObject* o = jsonNewObject(NULL);
 142         o->type = JSON_NUMBER;
 143         o->value.s = doubleToString( num );
 144         return o;
 145 }
 146
 147 /**
 148  * Creates a new number object from a numeric string
 149  */
 150 jsonObject* jsonNewNumberStringObject( const char* numstr ) {
 151         if( !numstr )
 152                 numstr = "0";
 153         else if( !jsonIsNumeric( numstr ) )
 154                 return NULL;
 155
 156         jsonObject* o = jsonNewObject(NULL);
 157         o->type = JSON_NUMBER;
 158         o->value.s = strdup( numstr );
 159         return o;
 160 }
 161
 162 jsonObject* jsonNewBoolObject(int val) {
 163     jsonObject* o = jsonNewObject(NULL);
 164     o->type = JSON_BOOL;
 165     jsonSetBool(o, val);
 166     return o;
 167 }
 168
 169 jsonObject* jsonNewObjectType(int type) {
 170         jsonObject* o = jsonNewObject(NULL);
 171         o->type = type;
 172         return o;
 173 }
 174
 175 void jsonObjectFree( jsonObject* o ) {
 176
 177         if(!o || o->parent) return;
 178         free(o->classname);
 179
 180         switch(o->type) {
 181                 case JSON_HASH          : osrfHashFree(o->value.h); break;
 182                 case JSON_ARRAY : osrfListFree(o->value.l); break;
 183                 case JSON_STRING        : free(o->value.s); break;
 184                 case JSON_NUMBER        : free(o->value.s); break;
 185         }
 186
 187         // Stick the old jsonObject onto a free list
 188         // for potential reuse
 189
 190         unusedObj* unused = (unusedObj*) o;
 191         unused->next = freeObjList;
 192         freeObjList = unused;
 193
 194     unusedObjCapture++;
 195     currentListLen++;
 196     if (unusedObjCapture > 1 && !(unusedObjCapture % 1000))
 197         osrfLogDebug( OSRF_LOG_MARK, "Objects malloc()'d: %d, Reusable objects captured: %d, Objects reused: %d, Current List Length: %d", mallocObjCreate, unusedObjCapture, unusedObjRelease, currentListLen );
 198 }
 199
 200 static void _jsonFreeHashItem(char* key, void* item){
 201         if(!item) return;
 202         jsonObject* o = (jsonObject*) item;
 203         o->parent = NULL; /* detach the item */
 204         jsonObjectFree(o);
 205 }
 206 static void _jsonFreeListItem(void* item){
 207         if(!item) return;
 208         jsonObject* o = (jsonObject*) item;
 209         o->parent = NULL; /* detach the item */
 210         jsonObjectFree(o);
 211 }
 212
 213 void jsonSetBool(jsonObject* bl, int val) {
 214     if(!bl) return;
 215     JSON_INIT_CLEAR(bl, JSON_BOOL);
 216     bl->value.b = val;
 217 }
 218
 219 unsigned long jsonObjectPush(jsonObject* o, jsonObject* newo) {
 220     if(!o) return -1;
 221     if(!newo) newo = jsonNewObject(NULL);
 222         JSON_INIT_CLEAR(o, JSON_ARRAY);
 223         newo->parent = o;
 224         osrfListPush( o->value.l, newo );
 225         o->size = o->value.l->size;
 226         return o->size;
 227 }
 228
 229 unsigned long jsonObjectSetIndex(jsonObject* dest, unsigned long index, jsonObject* newObj) {
 230     if(!dest) return -1;
 231     if(!newObj) newObj = jsonNewObject(NULL);
 232         JSON_INIT_CLEAR(dest, JSON_ARRAY);
 233         newObj->parent = dest;
 234         osrfListSet( dest->value.l, newObj, index );
 235         dest->size = dest->value.l->size;
 236         return dest->value.l->size;
 237 }
 238
 239 unsigned long jsonObjectSetKey( jsonObject* o, const char* key, jsonObject* newo) {
 240     if(!o) return -1;
 241     if(!newo) newo = jsonNewObject(NULL);
 242         JSON_INIT_CLEAR(o, JSON_HASH);
 243         newo->parent = o;
 244         osrfHashSet( o->value.h, newo, key );
 245         o->size = osrfHashGetCount(o->value.h);
 246         return o->size;
 247 }
 248
 249 jsonObject* jsonObjectGetKey( jsonObject* obj, const char* key ) {
 250         if(!(obj && obj->type == JSON_HASH && obj->value.h && key)) return NULL;
 251         return osrfHashGet( obj->value.h, key);
 252 }
 253
 254 const jsonObject* jsonObjectGetKeyConst( const jsonObject* obj, const char* key ) {
 255         if(!(obj && obj->type == JSON_HASH && obj->value.h && key)) return NULL;
 256         return osrfHashGet( obj->value.h, key);
 257 }
 258
 259 char* jsonObjectToJSON( const jsonObject* obj ) {
 260         jsonObject* obj2 = jsonObjectEncodeClass( obj );
 261         char* json = jsonObjectToJSONRaw(obj2);
 262         jsonObjectFree(obj2);
 263         return json;
 264 }
 265
 266 char* jsonObjectToJSONRaw( const jsonObject* obj ) {
 267         if(!obj) return NULL;
 268         growing_buffer* buf = buffer_init(32);
 269         add_json_to_buffer( obj, buf );
 270         return buffer_release( buf );
 271 }
 272
 273 static void add_json_to_buffer( const jsonObject* obj, growing_buffer * buf ) {
 274
 275         switch(obj->type) {
 276
 277                 case JSON_BOOL :
 278                         if(obj->value.b) OSRF_BUFFER_ADD(buf, "true");
 279                         else OSRF_BUFFER_ADD(buf, "false");
 280                         break;
 281
 282                 case JSON_NUMBER: {
 283                         if(obj->value.s) OSRF_BUFFER_ADD( buf, obj->value.s );
 284                         else OSRF_BUFFER_ADD_CHAR( buf, '0' );
 285                         break;
 286                 }
 287
 288                 case JSON_NULL:
 289                         OSRF_BUFFER_ADD(buf, "null");
 290                         break;
 291
 292                 case JSON_STRING:
 293                         OSRF_BUFFER_ADD_CHAR(buf, '"');
 294                         char* data = obj->value.s;
 295                         int len = strlen(data);
 296
 297                         char* output = uescape(data, len, 1);
 298                         OSRF_BUFFER_ADD(buf, output);
 299                         free(output);
 300                         OSRF_BUFFER_ADD_CHAR(buf, '"');
 301                         break;
 302
 303                 case JSON_ARRAY: {
 304                         OSRF_BUFFER_ADD_CHAR(buf, '[');
 305                         if( obj->value.l ) {
 306                                 int i;
 307                                 for( i = 0; i != obj->value.l->size; i++ ) {
 308                                         if(i > 0) OSRF_BUFFER_ADD(buf, ",");
 309                                         add_json_to_buffer( OSRF_LIST_GET_INDEX(obj->value.l, i), buf );
 310                                 }
 311                         }
 312                         OSRF_BUFFER_ADD_CHAR(buf, ']');
 313                         break;
 314                 }
 315
 316                 case JSON_HASH: {
 317
 318                         OSRF_BUFFER_ADD_CHAR(buf, '{');
 319                         osrfHashIterator* itr = osrfNewHashIterator(obj->value.h);
 320                         jsonObject* item;
 321                         int i = 0;
 322
 323                         while( (item = osrfHashIteratorNext(itr)) ) {
 324                                 if(i++ > 0) OSRF_BUFFER_ADD(buf, ",");
 325                                 buffer_fadd(buf, "\"%s\":", osrfHashIteratorKey(itr));
 326                                 add_json_to_buffer( item, buf );
 327                         }
 328
 329                         osrfHashIteratorFree(itr);
 330                         OSRF_BUFFER_ADD_CHAR(buf, '}');
 331                         break;
 332                 }
 333         }
 334 }
 335
 336
 337 jsonIterator* jsonNewIterator(const jsonObject* obj) {
 338         if(!obj) return NULL;
 339         jsonIterator* itr;
 340         OSRF_MALLOC(itr, sizeof(jsonIterator));
 341
 342         itr->obj                = (jsonObject*) obj;
 343         itr->index      = 0;
 344         itr->key                = NULL;
 345
 346         if( obj->type == JSON_HASH )
 347                 itr->hashItr = osrfNewHashIterator(obj->value.h);
 348
 349         return itr;
 350 }
 351
 352 void jsonIteratorFree(jsonIterator* itr) {
 353         if(!itr) return;
 354         free(itr->key);
 355         osrfHashIteratorFree(itr->hashItr);
 356         free(itr);
 357 }
 358
 359 jsonObject* jsonIteratorNext(jsonIterator* itr) {
 360         if(!(itr && itr->obj)) return NULL;
 361         if( itr->obj->type == JSON_HASH ) {
 362                 if(!itr->hashItr) return NULL;
 363                 jsonObject* item = osrfHashIteratorNext(itr->hashItr);
 364         if(!item) return NULL;
 365                 free(itr->key);
 366                 itr->key = strdup( osrfHashIteratorKey(itr->hashItr) );
 367                 return item;
 368         } else {
 369                 return jsonObjectGetIndex( itr->obj, itr->index++ );
 370         }
 371 }
 372
 373 int jsonIteratorHasNext(const jsonIterator* itr) {
 374         if(!(itr && itr->obj)) return 0;
 375         if( itr->obj->type == JSON_HASH )
 376                 return osrfHashIteratorHasNext( itr->hashItr );
 377         return (itr->index < itr->obj->size) ? 1 : 0;
 378 }
 379
 380 jsonObject* jsonObjectGetIndex( const jsonObject* obj, unsigned long index ) {
 381         if(!obj) return NULL;
 382         return (obj->type == JSON_ARRAY) ?
 383         (OSRF_LIST_GET_INDEX(obj->value.l, index)) : NULL;
 384 }
 385
 386
 387
 388 unsigned long jsonObjectRemoveIndex(jsonObject* dest, unsigned long index) {
 389         if( dest && dest->type == JSON_ARRAY ) {
 390                 osrfListRemove(dest->value.l, index);
 391                 return dest->value.l->size;
 392         }
 393         return -1;
 394 }
 395
 396
 397 unsigned long jsonObjectRemoveKey( jsonObject* dest, const char* key) {
 398         if( dest && key && dest->type == JSON_HASH ) {
 399                 osrfHashRemove(dest->value.h, key);
 400                 return 1;
 401         }
 402         return -1;
 403 }
 404
 405 /**
 406  Allocate a buffer and format a specified numeric value into it.
 407  Caller is responsible for freeing the buffer.
 408 **/
 409 char* doubleToString( double num ) {
 410
 411         char buf[ 64 ];
 412         size_t len = snprintf(buf, sizeof( buf ), "%.30g", num) + 1;
 413         if( len < sizeof( buf ) )
 414                 return strdup( buf );
 415         else
 416         {
 417                 // Need a bigger buffer (should never be necessary)
 418
 419                 char* bigger_buff = safe_malloc( len + 1 );
 420                 (void) snprintf(bigger_buff, len + 1, "%.30g", num);
 421                 return bigger_buff;
 422         }
 423 }
 424
 425 char* jsonObjectGetString(const jsonObject* obj) {
 426         if(obj)
 427         {
 428                 if( obj->type == JSON_STRING )
 429                         return obj->value.s;
 430                 else if( obj->type == JSON_NUMBER )
 431                         return obj->value.s ? obj->value.s : "0";
 432                 else
 433                         return NULL;
 434         }
 435         else
 436                 return NULL;
 437 }
 438
 439 double jsonObjectGetNumber( const jsonObject* obj ) {
 440         return (obj && obj->type == JSON_NUMBER && obj->value.s)
 441                         ? strtod( obj->value.s, NULL ) : 0;
 442 }
 443
 444 void jsonObjectSetString(jsonObject* dest, const char* string) {
 445         if(!(dest && string)) return;
 446         JSON_INIT_CLEAR(dest, JSON_STRING);
 447         dest->value.s = strdup(string);
 448 }
 449
 450 /**
 451  Turn a jsonObject into a JSON_NUMBER (if it isn't already one) and store
 452  a specified numeric string in it.  If the string is not numeric,
 453  store the equivalent of zero, and return an error status.
 454 **/
 455 int jsonObjectSetNumberString(jsonObject* dest, const char* string) {
 456         if(!(dest && string)) return -1;
 457         JSON_INIT_CLEAR(dest, JSON_NUMBER);
 458
 459         if( jsonIsNumeric( string ) ) {
 460                 dest->value.s = strdup(string);
 461                 return 0;
 462         }
 463         else {
 464                 dest->value.s = NULL;  // equivalent to zero
 465                 return -1;
 466         }
 467 }
 468
 469 void jsonObjectSetNumber(jsonObject* dest, double num) {
 470         if(!dest) return;
 471         JSON_INIT_CLEAR(dest, JSON_NUMBER);
 472         dest->value.s = doubleToString( num );
 473 }
 474
 475 void jsonObjectSetClass(jsonObject* dest, const char* classname ) {
 476         if(!(dest && classname)) return;
 477         free(dest->classname);
 478         dest->classname = strdup(classname);
 479 }
 480 const char* jsonObjectGetClass(const jsonObject* dest) {
 481     if(!dest) return NULL;
 482     return dest->classname;
 483 }
 484
 485 jsonObject* jsonObjectClone( const jsonObject* o ) {
 486     if(!o) return jsonNewObject(NULL);
 487
 488     int i;
 489     jsonObject* arr;
 490     jsonObject* hash;
 491     jsonIterator* itr;
 492     jsonObject* tmp;
 493     jsonObject* result = NULL;
 494
 495     switch(o->type) {
 496         case JSON_NULL:
 497             result = jsonNewObject(NULL);
 498             break;
 499         case JSON_STRING:
 500             result = jsonNewObject(jsonObjectGetString(o));
 501             break;
 502         case JSON_NUMBER:
 503                         result = jsonNewObject( o->value.s );
 504                         result->type = JSON_NUMBER;
 505             break;
 506         case JSON_BOOL:
 507             result = jsonNewBoolObject(jsonBoolIsTrue((jsonObject*) o));
 508             break;
 509         case JSON_ARRAY:
 510             arr = jsonNewObject(NULL);
 511             arr->type = JSON_ARRAY;
 512             for(i=0; i < o->size; i++)
 513                 jsonObjectPush(arr, jsonObjectClone(jsonObjectGetIndex(o, i)));
 514             result = arr;
 515             break;
 516         case JSON_HASH:
 517             hash = jsonNewObject(NULL);
 518             hash->type = JSON_HASH;
 519             itr = jsonNewIterator(o);
 520             while( (tmp = jsonIteratorNext(itr)) )
 521                 jsonObjectSetKey(hash, itr->key, jsonObjectClone(tmp));
 522             jsonIteratorFree(itr);
 523             result = hash;
 524             break;
 525     }
 526
 527     jsonObjectSetClass(result, jsonObjectGetClass(o));
 528     return result;
 529 }
 530
 531 int jsonBoolIsTrue( const jsonObject* boolObj ) {
 532     if( boolObj && boolObj->type == JSON_BOOL && boolObj->value.b )
 533         return 1;
 534     return 0;
 535 }
 536
 537
 538 char* jsonObjectToSimpleString( const jsonObject* o ) {
 539         if(!o) return NULL;
 540
 541         char* value = NULL;
 542
 543         switch( o->type ) {
 544
 545                 case JSON_NUMBER:
 546                         value = strdup( o->value.s ? o->value.s : "0" );
 547                         break;
 548
 549                 case JSON_STRING:
 550                         value = strdup(o->value.s);
 551         }
 552
 553         return value;
 554 }
 555
 556 /**
 557  Return 1 if the string is numeric, otherwise return 0.
 558  This validation follows the rules defined by the grammar at:
 559  http://www.json.org/
 560  **/
 561 int jsonIsNumeric( const char* s ) {
 562
 563         if( !s || !*s ) return 0;
 564
 565         const char* p = s;
 566
 567         // skip leading minus sign, if present (leading plus sign not allowed)
 568
 569         if( '-' == *p )
 570                 ++p;
 571
 572         // There must be at least one digit to the left of the decimal
 573
 574         if( isdigit( (unsigned char) *p ) ) {
 575                 if( '0' == *p++ ) {
 576
 577                         // If the first digit is zero, it must be the
 578                         // only digit to the lerft of the decimal
 579
 580                         if( isdigit( (unsigned char) *p ) )
 581                                 return 0;
 582                 }
 583                 else {
 584
 585                         // Skip oer the following digits
 586
 587                         while( isdigit( (unsigned char) *p ) ) ++p;
 588                 }
 589         }
 590         else
 591                 return 0;
 592
 593         if( !*p )
 594                 return 1;             // integer
 595
 596         if( '.' == *p ) {
 597
 598                 ++p;
 599
 600                 // If there is a decimal point, there must be
 601                 // at least one digit to the right of it
 602
 603                 if( isdigit( (unsigned char) *p ) )
 604                         ++p;
 605                 else
 606                         return 0;
 607
 608                 // skip over contiguous digits
 609
 610                 while( isdigit( (unsigned char) *p ) ) ++p;
 611         }
 612
 613         if( ! *p )
 614                 return 1;  // decimal fraction, no exponent
 615         else if( *p != 'e' && *p != 'E' )
 616                 return 0;  // extra junk, no exponent
 617         else
 618                 ++p;
 619
 620         // If we get this far, we have the beginnings of an exponent.
 621         // Skip over optional sign of exponent.
 622
 623         if( '-' == *p || '+' == *p )
 624                 ++p;
 625
 626         // There must be at least one digit in the exponent
 627
 628         if( isdigit( (unsigned char) *p ) )
 629                 ++p;
 630         else
 631                 return 0;
 632
 633         // skip over contiguous digits
 634
 635         while( isdigit( (unsigned char) *p ) ) ++p;
 636
 637         if( *p )
 638                 return 0;  // extra junk
 639         else
 640                 return 1;  // number with exponent
 641 }
 642
 643 /**
 644  Allocate and reformat a numeric string into one that is valid
 645  by JSON rules.  If the string is not numeric, return NULL.
 646  Caller is responsible for freeing the buffer.
 647  **/
 648 char* jsonScrubNumber( const char* s ) {
 649         if( !s || !*s ) return NULL;
 650
 651         growing_buffer* buf = buffer_init( 64 );
 652
 653         // Skip leading white space, if present
 654
 655         while( isspace( (unsigned char) *s ) ) ++s;
 656
 657         // Skip leading plus sign, if present, but keep a minus
 658
 659         if( '-' == *s )
 660         {
 661                 buffer_add_char( buf, '-' );
 662                 ++s;
 663         }
 664         else if( '+' == *s )
 665                 ++s;
 666
 667         if( '\0' == *s ) {
 668                 // No digits found
 669
 670                 buffer_free( buf );
 671                 return NULL;
 672         }
 673         // Skip any leading zeros
 674
 675         while( '0' == *s ) ++s;
 676
 677         // Capture digits to the left of the decimal,
 678         // and note whether there are any.
 679
 680         int left_digit = 0;  // boolean
 681
 682         if( isdigit( (unsigned char) *s ) ) {
 683                 buffer_add_char( buf, *s++ );
 684                 left_digit = 1;
 685         }
 686
 687         while( isdigit( (unsigned char) *s  ) )
 688                 buffer_add_char( buf, *s++ );
 689
 690         // Now we expect to see a decimal point,
 691         // an exponent, or end-of-string.
 692
 693         switch( *s )
 694         {
 695                 case '\0' :
 696                         break;
 697                 case '.' :
 698                 {
 699                         // Add a single leading zero, if we need to
 700
 701                         if( ! left_digit )
 702                                 buffer_add_char( buf, '0' );
 703                         buffer_add_char( buf, '.' );
 704                         ++s;
 705
 706                         if( ! left_digit && ! isdigit( (unsigned char) *s ) )
 707                         {
 708                                 // No digits on either side of decimal
 709
 710                                 buffer_free( buf );
 711                                 return NULL;
 712                         }
 713
 714                         // Collect digits to right of decimal
 715
 716                         while( isdigit( (unsigned char) *s ) )
 717                                 buffer_add_char( buf, *s++ );
 718
 719                         break;
 720                 }
 721                 case 'e' :
 722                 case 'E' :
 723
 724                         // Exponent; we'll deal with it later, but
 725                         // meanwhile make sure we have something
 726                         // to its left
 727
 728                         if( ! left_digit )
 729                                 buffer_add_char( buf, '1' );
 730                         break;
 731                 default :
 732
 733                         // Unexpected character; bail out
 734
 735                         buffer_free( buf );
 736                         return NULL;
 737         }
 738
 739         if( '\0' == *s )    // Are we done yet?
 740                 return buffer_release( buf );
 741
 742         if( 'e' != *s && 'E' != *s ) {
 743
 744                 // Unexpected character: bail out
 745
 746                 buffer_free( buf );
 747                 return NULL;
 748         }
 749
 750         // We have an exponent.  Load the e or E,
 751         // and the sign if there is one.
 752
 753         buffer_add_char( buf, *s++ );
 754
 755         if( '+' == *s || '-' == *s )
 756                 buffer_add_char( buf, *s++ );
 757
 758         // Collect digits of the exponent
 759
 760         while( isdigit( (unsigned char) *s ) )
 761                 buffer_add_char( buf, *s++ );
 762
 763         // There better not be anything left
 764
 765         if( *s ) {
 766                 buffer_free( buf );
 767                 return NULL;
 768         }
 769
 770         return buffer_release( buf );
 771 }