---

dt_stream_text.c

Go to the documentation of this file.

#include "dt_stream_text.h"
#include "dt_stream_base.h"
#include "dt_buf.h"

#include <malloc.h>
#include <ctype.h>
#include <assert.h>


enum {
  eCommentMark  = '#',  
  ePasQuote     = '\'', 
  eArrayOpen    = '(',  
  eArrayClose   = ')',  
  eRecordOpen   = '{',  
  eRecordClose  = '}',  
  eKeyMark      = ':',  
};

static dt_bool isIdentifierChar(int c)
{
   if( isalnum(c) )
      return 1;

   switch(c)
   {
   case '+': case '-': case '.': case '_':
      return 1;
   default:
      return 0;
   }
}


/*===================================================================*/
/*       reader object implementation                                */


typedef struct
{
   dt_reader base;     
   FILE*     src;      
   dt_buf    key, val; 
} dt_reader_text;

static void dt_reader_text_free( dt_reader* obj );

static dt_bool dt_reader_text_read( dt_reader* obj, dt_stream_step* step );

dt_reader*
dt_create_text_reader( FILE* src, dt_text_mode_flags flags )
{
   dt_reader_text* ans = (dt_reader_text*)malloc(sizeof(dt_reader_text));
   if( ans )
   {
      dt_init_reader_base( & ans->base, & dt_reader_text_free, & dt_reader_text_read );
      ans->src = src;
      if( dt_buf_init( & ans->key ) )
      {
         if( dt_buf_init( & ans->val ) )
            return & ans->base;
         dt_buf_free( & ans->key );
      }
      free(ans);
   }
   return 00;
}

static void dt_reader_text_free( dt_reader* obj )
{
   dt_reader_text* o = (dt_reader_text*)obj;
   dt_buf_free( & o->key );
   dt_buf_free( & o->val );
   free( o );
}

static int skipBlanks( FILE* const src );
static int readIdentifier( FILE* const src, dt_buf* buf );

static dt_bool dt_reader_text_read( dt_reader* obj, dt_stream_step* step )
{
   dt_reader_text* const o = (dt_reader_text*)obj;
   FILE* const src = o->src;

   int c = skipBlanks( src );

   step->key     = 00;
   step->key_len = 0;
   step->val     = 00;
   step->val_len = 0;

   switch( c ) {
      case eArrayOpen:    step->kind = dt_arr_in;   return 1;
      case eArrayClose:   step->kind = dt_arr_out;  return 1;
      case eRecordOpen:   step->kind = dt_rec_in;   return 1;
      case eRecordClose:  step->kind = dt_rec_out;  return 1;
      case EOF:           step->kind = dt_end;      return 1;    
      default:  ungetc(c,src); break; /* put char back and go on... */
   }

   c = readIdentifier( src, & o->key );
   if (c != eKeyMark) {
      step->kind    = dt_leaf;
      step->val     = o->key.begin;
      step->val_len = o->key.strEnd - step->val;
      return 1;
   }
   fgetc(src); /* skip the key mark */
   step->key     = o->key.begin;
   step->key_len = o->key.strEnd-step->key;
   c = skipBlanks(src);

   switch (c) {
      case eArrayOpen:    step->kind = dt_arr_in;  return 1;
      case eRecordOpen:   step->kind = dt_rec_in;  return 1;
      default:  ungetc(c,src); break; /* put char back and go on... */
   }

   c = readIdentifier( src, & o->val );
   if ( c==0  ||  c==eKeyMark ) {
      step->key     = 00;
      step->key_len = 0;
      return 0; /* c==eKeyMark --> throw("Unexpected key mark (:)"); */
   }

   step->kind    = dt_leaf;
   step->val     = o->val.begin;
   step->val_len = o->val.strEnd-step->val;
   return 1;
}


static int skipBlanks(FILE* const src)
{
   int c = fgetc(src);
   for(;;)
   {
      while( isspace(c) || (c==',') )
         c = fgetc(src);

      if ( c != eCommentMark )
         break;
      /* skip comment until end of line */
      do {  c = fgetc(src);  } while ( c!='\n' && c!='\r' && c!=EOF );
   }
   return c; 
}

static int readIdentifier(FILE* const src, dt_buf* buf)
{
   int c = fgetc(src);

   dt_buf_clear( buf );

   if( isIdentifierChar(c) ) /* naked/simple identifier */
   {
      do {
         if(! dt_buf_append( buf, c ) )return 0; /* throw out of mem */
         c = fgetc(src);
      } while ( isIdentifierChar(c) );
   }
   else
   {
      if (c!=ePasQuote)
         return 0;/*throw("Identifier Expected"); */

      for(;;)
      {
         c = fgetc(src);
         if (c==ePasQuote)
         {
            c = fgetc(src); /* end reached unless is a double quote */
            if (c!=ePasQuote)
               break;
         }
         else if (c==EOF)
            return 0;/*throw("End Quote Missing (')"); */

         if(! dt_buf_append( buf, c ) )return 0; /* throw out of mem */
      }
   }
   ungetc( c, src );
   return (c==eKeyMark) ? c : 1;    
}


/*===================================================================*/
/*       writer object implementation                                */


typedef struct
{
   dt_writer         base;
   FILE*              dst;
   dt_text_mode_flags mode;
   int                depth;
   dt_step_kind       lastKind;
} dt_writer_text;


static void    dt_writer_text_free( dt_writer* obj );
static dt_bool dt_writer_text_write( dt_writer* obj, dt_stream_step const* step );


dt_writer*
dt_create_text_writer( FILE* dst, dt_text_mode_flags mode )
{
   dt_writer_text* ans = (dt_writer_text*)malloc(sizeof(dt_writer_text));
   if( ans )
   {
      dt_init_writer_base( & ans->base, & dt_writer_text_free, & dt_writer_text_write );
      ans->dst = dst;
      ans->mode = mode;
      ans->depth = 0;
      ans->lastKind = dt_end;
      return & ans->base;
   }
   return 00;
}


static void dt_writer_text_free(dt_writer* obj)
{
   dt_writer_text* o = (dt_writer_text*)obj;
   free( o );
}


static dt_bool sendChar(dt_writer_text* o, int c);
static dt_bool startNewLine(dt_writer_text* o);
static dt_bool writeIdentifier(dt_writer_text* o
                  , dt_byte const* base, dt_byte const* end);

static dt_bool dt_writer_text_write(dt_writer* obj, dt_stream_step const* step)
{
   dt_bool ok;
   dt_writer_text* o = (dt_writer_text*)obj;
   dt_step_kind lastKind = o->lastKind;
   o->lastKind = step->kind;
   
   switch (step->kind)
   {
   case dt_end:
      o->depth = 0;
      return startNewLine(o) && 0==fflush( o->dst );
   case dt_arr_out:
      -- o->depth;
      if( ! (o->mode & dt_text_packed) )
         if ( 0 == o->depth )
            ok = startNewLine(o);
         else
            ok = sendChar(o,' ');
      else
        ok = 1;
      return ok && sendChar(o,eArrayClose);
   case dt_rec_out:
      -- o->depth;
      return startNewLine(o) && sendChar(o,eRecordClose);
   }

   if( step->key ) /* step is within a record */
   {
      int const packed = (o->mode & dt_text_packed);
      if( ! packed )
      {
         if( ! startNewLine(o) ) return 0;
      }
      else {
         if( lastKind == dt_leaf )
            if( ! sendChar( o, ' ' ) ) return 0;
      }
      if(!(    writeIdentifier( o, step->key, step->key + step->key_len )
            && sendChar( o, eKeyMark )
            && ( packed || sendChar( o, '\t' ) )
         )) return 0;
   }
   else if (o->depth > 0) /* step is within an array */
   {
      ok = (lastKind == dt_arr_in) || sendChar( o, ',' );
      if( ! (o->mode & dt_text_packed) )
         if( 1 == o->depth )
            ok = ok && startNewLine(o);
         else {
            if ( lastKind==dt_rec_out && step->kind==dt_rec_in )
               ok = ok && startNewLine(o);
            ok = ok && sendChar( o, ' ' );
         } 
      if( ! ok ) return 0;
   }

   switch (step->kind)
   {
   case dt_arr_in:
      ++ o->depth;
      return sendChar( o, eArrayOpen );
   case dt_rec_in:
      ++ o->depth;
      return sendChar( o, eRecordOpen );
   case dt_leaf:
      return writeIdentifier( o, step->val, step->val + step->val_len );
   }
   return 1;
}


static dt_bool sendChar( dt_writer_text* o, int c)
{
   assert( !! o );
/* putchar( c ); /*TEMP for console debugging */
   return fputc( c, o->dst ) != EOF;
}

static dt_bool startNewLine( dt_writer_text* o )
{
   int i;

   assert( !! o );

   if( o->mode & dt_text_packed )
      return 1;

   if( o->mode & dt_text_crlf ) /* force explicit CR before LF for line end */
      if(! sendChar(o,'\r') ) return 0;

   if(! sendChar(o,'\n') ) return 0;

   for( i = o->depth ; i>0 ; --i )
      if(! sendChar(o,'\t') ) return 0;
   return 1;
}


static dt_bool writeIdentifier( dt_writer_text* o
                              , dt_byte const* base, dt_byte const* end)
{
   dt_bool needQuote = 0;
   dt_byte const* scan;

   assert( !! o );

   if( base == end )
      needQuote = 1; /* must quote empty string */
   else
      for( scan = base ; scan != end ; ++scan )
         if( ! isIdentifierChar(*scan) )
         {
            needQuote = 1;
            break;
         }

   if( needQuote )
   {
      if(! sendChar(o,ePasQuote) ) return 0;
      for ( scan = base ; scan != end ; ++scan )
      {
         if (*scan!=ePasQuote) {
            if(! sendChar(o,*scan) ) return 0;
         }
         else {
            if(! sendChar(o,ePasQuote) ) return 0;
            if(! sendChar(o,ePasQuote) ) return 0;
         } 
      }       
      if(! sendChar(o,ePasQuote) ) return 0;
   }
   else
   {
      for ( scan = base ; scan != end ; ++scan )
         if(! sendChar(o,*scan) ) return 0;
   }
   return 1;
}

---