Search  

---

C:/temp/src/j2k/nto/bakJuly/FileReader.cpp

Go to the documentation of this file.

#ifndef __J2K__FileReader_CPP__
#define __J2K__FileReader_CPP__

#include <j2k/nto/ANSI.hpp>
#include <j2k/nto/FileReader.hpp>
#include <j2k/nto/Track.hpp>
#include <j2k/nto/File.hpp>

FileReader::FileReader( const char* n = "circle.trk" )
   {
      file = new File( n );
      memset( buffer, 0, 4096 );
      memset( &trk_init,    0, sizeof( trk_init    ) );
      memset( &trk_info,    0, sizeof( trk_info    ) );
      memset( &trk_segment, 0, sizeof( trk_segment ) );
      segments = NULL;  
      len = 0;
   }

   FileReader::~FileReader() 
   { 
     if ( file     ) delete   file;
     if ( segments ) delete[] segments;

     file     = NULL;
     segments = NULL;
   }

   void FileReader::load() 
   {
     len = file->read( buffer, 4096 );
   }

   void FileReader::find() 
   {
     char* start = buffer;
     char* ends  = NULL;
     size_t len2  = len;
     char buf[4096];
     memset( buf, 0, 4096 );

// vd2[ dir ][ speed ]
dvect_1D  vd1( 30, 0.0f );

// vdlength[ straight/curved ][ length ]
dvect_2D  vdlength( 2, vd1 );


     register int    i = 0;
     
     double d[ 10 ];
     memset( d, 0, sizeof( double ) * 10 );

     for(;;) 
     {
       ends = (char*)memchr( start, '\n', len2 );
       if ( ends == NULL   ) return;

       if ( ends >= buffer+4096 ) return;

   size_t l = (size_t)(ends-start+1);
       memcpy( buf, start, l );
       buf[l] = 0; 
       
       len2 += l;    

   QBColor();
       switch( start[0] )
       {
     case '#': comment( buf, l ); 
          break;

     case '%': trk_init = init(    buf, l ); 
            if ( segments ) delete[] segments;

            size = trk_init.end_bit + 1;
            segments = new Track*[ size ];
          break;

     case '@': trk_info = info(    buf, l ); 

       i = (int)trk_info.type;

            if ( i > 0 )
            {
              vdlength[ i ][ trk_info.name ] = trk_info.size;
            }

          break;

     case '$': 

            trk_segment = track(   buf, l ); 

            for( int j = 0; j < trk_segment.max_path; j++ )
            {
              i = (int)trk_segment.type[ j ];
              d[j] = vdlength[ i ][ trk_segment.length_name[ j ] ];
            }

            i = trk_segment.bit_name;
            segments[ i ] = new Track( trk_init, trk_segment, d );
          break;

     default :  
       printf( "\nUnknown: %s", buf ); break;
       }
       start = ends+1;
     }
  }

  Track** FileReader::getTracks() const {
    return segments;
  }

  void FileReader::comment( const char* buf, size_t len )
  {
    printf( "\nComment: %s \t", buf );
  }

// Should verify tokens delims and validate the order of the sequence !

  track_info_t FileReader::info( const char* buf, size_t len )
  {
    printf( "\nInfo: %s    \t",    buf );

    size_t i = 0;
    char   c = 0;

    track_info_t info;

    memset( &info, 0, sizeof( info ) );

    assert ( buf[i] == '@' );
   
    i++;
    if ( buf[i] == 'S' || buf[i] == 's' )
    {
      info.type = TrackType_STRAIGHT;

    } else 
     if ( buf[i] == 'C' || buf[i] == 'c' )
    {
      info.type = TrackType_CURVED; 
    } else 
    {
      info.type = TrackType_UNDEFINED;
    }

    i++;    

    const char* s = buf+i;
    long v = strtol( s, NULL, 10 );
    
    info.name = v;

    for( ; i < len; i++ )
    {
      c = buf[i];
      if ( c != '=' ) continue;

      const char* s2 = buf+i+1;
      double d = strtod( s2, NULL );
      info.size = d;
      break;
    }

    printf( "[%d,%ld,%0.6f]", 
            info.type, info.name,
            info.size );

    return info;
  }

  track_init_t  FileReader::init( const char* buf, size_t len )
  {
    printf( "\nInit: %s    \t",    buf );

    size_t i = 0;
    char   c = 0;

    track_init_t info;

    memset( &info, -1, sizeof( info ) );

    char*  delims = { "%-,,;" };
    size_t d = 0;

    for( i = 0; i < len; i++ )
    {
      c = buf[i];
      if ( c == delims[d] ) 
      { 
        d++; 
        i++; 
        const char* s = buf+i;
        long v = strtol( s, NULL, 10 );
        switch( d )
        {
          case 1: info.start_bit = v; break;
          case 2: info.end_bit   = v; break;
          case 3: info.max_left  = v; break;
          case 4: info.max_right = v; break;
          default: break;
        }
      }    
    }

    QBColor( 14, 0 );
    printf( "[%ld,%ld,%ld,%ld]\n", 
            info.start_bit, info.end_bit, 
            info.max_left,  info.max_right );

    return info;
  }

  void FileReader::parenth( const char* start, size_t len, long* array, size_t sz )
  {
    char buf[120];
    memset( buf, 0, 120 );
    memcpy( buf, start, len );
 
    QBColor( 10, 0 );
    printf("|%s| ", buf );
    QBColor();
  
    register size_t i = 0; 
    register long v = strtol( start, NULL, 10 );
    array[0] = v;    

    register size_t k = 1;

    for( i = 0; i < len; i++ )
    {
      if ( start[i] != ',' ) continue;

      i++; 
      v = strtol( start+i, NULL, 10 );   
      array[k] = v;
      k++;
    } 
  }

  track_segment_t FileReader::track( const char* buf, size_t len )
  {
    printf( "\nTrack: %s    \t",    buf );

    size_t i = 0;
    char   c = 0;
    size_t index = 0;

    size_t sz = 0;

    track_segment_t info;

    memset( &info,           0, sizeof( info          ) );
    memset( &info.left,     -1, sizeof( info.left     ) );
    memset( &info.right,    -1, sizeof( info.right    ) );
    memset( &info.switches, -1, sizeof( info.switches ) );

    assert ( buf[i] == '$' );
    i++;

    register long v = strtol( (const char*)(buf+i), NULL, 10 );

    info.bit_name = v;

    for( ; i < len; i++ )
    {
      if ( buf[i] == ':' ) break;
    }
    
    assert( i < len );
   
    QBColor();
    char* pLeftp  = (char*)memchr( buf+i, '(', len-i );
    char* pRightp = (char*)memchr( buf+i, ')', len-i );

    assert( pLeftp  != NULL );
    assert( pRightp != NULL );

    size_t nLeftp  = (size_t)(pLeftp  - buf);
    size_t nRightp = (size_t)(pRightp - buf);
 
    index = 0;
    for( i = nLeftp+1; i < nRightp; i++ )
    {
      while( buf[i] <= ' ' ) { i++; }

      if ( buf[i] == 'S' || buf[i] == 's' )
      {
        info.type[ index ] = TrackType_STRAIGHT;

      } else 
      if ( buf[i] == 'C' || buf[i] == 'c' )
      {
        info.type[ index ] = TrackType_CURVED; 
      } else 
      {
        info.type[ index ] = TrackType_UNDEFINED;
      }

      i++;
      const char* s = buf+i;
      v = strtol( s, NULL, 10 );
    
      info.length_name[ index ] = v;

//      QBColor( 10, 0 );  
//      printf("[%c%c|",    buf[i-1], buf[i] );
//      printf("%d%ld]\n\n", info.type[index], v );
 
      info.max_path = index;
     index++;
    }

    char*  delims = { ",,,L(),R(),S();" };
    size_t d = 0;

    for( ; i < len; i++ )
    {
      c = buf[i];
      if ( c == delims[d] ) 
      { 
        if ( c == 'L' || c == 'l' || c == 'R' || c == 'r' || c == 'S' || c == 'S' ) 
        {
          d++; 
          continue;
        }
        
        d++;
        i++; 
        const char* s = buf+i;
        v = strtol( s, NULL, 10 );
        long* array = NULL;
        char* end   = NULL;
        long length = 0;

//        QBColor( 14,0 );
//        printf("d=[%d] s=[%s]\n", d, s );

        switch( d )
        {
          case 1: 
            info.max_left  = v; 
            QBColor( 13, 0 );
            printf( "info.max_left = %ld ", v ); 
          break;
          
          case 2: 
            info.max_right = v; 
            QBColor( 11, 0 );
            printf( "info.max_right = %ld ", v ); 
          break;

          case 3: 
//            QBColor( 10, 0 );
//            printf( "Case 3 \n" );

            array = &( info.left[0] );
            end = strchr( s, ')' );
            length = (long)(end - (s + 2) + 1);
            if ( length <= 0 ) continue;

            i = length-1;

//            printf( "[%s]", s+2 );
            parenth( s+2, (size_t)(length-1), info.left, 10 );
          break;

          case 6:
//            QBColor( 15, 0 );
//            printf( "Case 6 \n" );

            array = &( info.right[0] );
            end = strchr( s, ')' );

            length = (long)(end - (s + 2) + 1);
//            if ( length <= 0 ) continue;

            
            i = length-1;

//            printf( "[%s]", s+3 );
            parenth( s+3, (size_t)(length-2), info.right, 10 );
          break;

          case 10:
//            QBColor( 15, 0 );
//            printf( "Case 10 \n" );

            array = &( info.switches[0] );
            end = strchr( s, ')' );

            length = (long)(end - (s + 2) + 1);
//            if ( length <= 0 ) continue;

            
            i = length-1;

            sz = (size_t)(length-2); 
//            printf( "[%s]%d]", s+3, sz );
            parenth( s+3, sz, info.switches, 10 );
          break;

          default: 
   break;
        }
      }    
    }

    QBColor( 15, 0);
    printf( "[%ld,%d,%ld,%ld,%ld]\nL{",
            info.bit_name, info.type[0], info.length_name[0],
            info.max_left,  info.max_right );
            fflush( stdout );

  
    QBColor( 14, 0 );
    register int n = 0;
    for( n = 0; n < 10; n++ )
    {
      printf( "%ld", info.left[n] );
      if ( n < 9 ) printf( "," );
    }

    printf( "}\nR{" );

    for( n = 0; n < 10; n++ )
    {
      printf( "%ld", info.right[n] );
      if ( n < 9 ) printf( "," );
    }

    printf( "}\nS{" );

    for( n = 0; n < 10; n++ )
    {
      printf( "%ld", info.switches[n] );
      if ( n < 9 ) printf( "," );
    }

    QBColor( 12, 0 );
    printf( "}\n" );
    fflush( stdout );

    return info;
  }
  

int main( int argc, char* argv[] )
{

//  printf( "%d", argc );
//  for( int i = 0; i < argc; i++ )
//   printf( "[%s]", argv[i] );

  printf("\n\n\n");

  FileReader* f = NULL;

  if ( argc > 1 ) {
    f = new FileReader( argv[1] );
  } else {
    f = new FileReader();
  }

  f->load();
  f->find();

  if ( f ) delete f;

  QBColor( 7, 0 );
  printf("\n\n\n");

  fflush( stdout );
  return 0;
}
#endif

---