source: orxonox.OLD/branches/terrain.old/src/lib/util/filesys/binary_file.cc @ 10596

#include "binary_file.h"
#include <ctype.h>
#include <stdlib.h>

int bytesize( const char _c )
{
  switch( _c)
  {
    case 'f':
    case 'i':
      return 4;
    case 'b':
      return 1;
    case 's':
      return 2;
    default:
      return 0;
  }
}

pDataSemantics BinaryFile::compileSemantics( const char *_semantics )
{
  const char *curr = _semantics;
  char *tmp = new char[strlen(_semantics)];
  //Find out how many subchunks exist.
  pDataSemantics chunk = new DataSemantics();
  bool terminated = false;
  int open = 0;
  while ( *curr )
  {
    switch( *curr )
    {
      case 'i':
      case 'f':
      case 'b':
      case 's':
        chunk->numChunkNodes++;
        break;
      case '(':
        terminated = false;
        chunk->numChunkNodes++;
        while ( *curr && terminated == false )
        {
          if ( *curr == ')' )
            terminated = true;
          curr++;
        }
        if ( !terminated )
        {
          printf( "Syntax error: ')' is missing" );
          delete chunk;
          return NULL;
        }
        break;
      default:
        break;
    }
    curr++;
  }
  //Compile the chunks...
  chunk->chunks = new pDataSemantics[chunk->numChunkNodes];
  int currChunk = 0;
  curr = _semantics;
  while ( *curr )
  {
    switch( *curr )
    {
      case 'i':
      case 'f':
      case 'b':
      case 's':
        chunk->chunks[currChunk] = new DataSemantics();
        chunk->chunks[currChunk]->isTerminal = true;
        chunk->chunks[currChunk]->type = bytesize( *curr );
        chunk->chunks[currChunk]->totalSize = bytesize( *curr );
        currChunk++;
        break;
        case '(': {
        curr++;
        open = 0;
        memset( tmp, 0, strlen( _semantics ) );
        char * cp = tmp;
        while ( *curr )
        {
          if ( *curr == '(' )
            open++;
          if ( *curr == ')' )
          {
            if ( open )
              open--;
            else
              break;
          }
          *cp = *curr;
          cp++;
          curr++;
        }
        *cp = '\0';
        chunk->chunks[currChunk] = compileSemantics( tmp );
        currChunk++;
        }
        break;
      case ')':
        printf( "Syntax error: ')' shouldn't appear here\n" );
        delete[] tmp; delete chunk;
        return NULL;
        break;
      default:
        int multiplier = 1, quantifier = 0;
        const char *start = curr;
        const char *end = curr;
        while ( isdigit( *end ) )
        {
          end++;
        }
        for ( const char *d = end-1; d >=start; --d )
        {
          quantifier+=multiplier*(*d-'0');
          multiplier*=10;
        }
        if ( start == end )
        {
          printf( "Syntax error: '%c' is not known.\n", *curr );
          delete[] tmp; delete chunk;
          return NULL;
        }
        if ( currChunk )
        {
          chunk->chunks[currChunk-1]->quantifier = quantifier;
          chunk->chunks[currChunk-1]->totalSize*= quantifier;
        }
        else
        {
          printf( "Syntax error: Quantifier without a preceding type\n" );
          delete[] tmp; delete chunk;
          return NULL;
        }
        curr = end-1;
        break;
    }
    curr++;
  }
  for ( int i = 0; i < chunk->numChunkNodes; ++i )
  {
    chunk->totalSize+= chunk->chunks[i]->totalSize;
  }
  delete[] tmp;
  return chunk;
}

void convert_data( pDataSemantics _comp, void *_data )
{
  char *ptr = (char*)_data;
  short *sptr;
  int *iptr;
  if ( _comp->isTerminal )
  {
    switch( _comp->type )
    {
      case TT_INT:
        iptr = (int*)ptr;
        for ( int i = 0; i < _comp->quantifier; ++i )
        {
          swap32( iptr );
          iptr++;
        }
        break;
      case TT_SHORT:
        sptr = (short*)ptr;
        for ( int i = 0; i < _comp->quantifier; ++i )
        {
          swap16( sptr );
          sptr++;
        }
        break;
      case TT_BYTE:
        break;
    }
  }
  else
  {
    for ( int j = 0; j < _comp->quantifier; ++j )
    {
      for ( int i = 0; i < _comp->numChunkNodes; ++i )
      {
        convert_data( _comp->chunks[i], ptr );
        ptr+= _comp->chunks[i]->totalSize;
      }
    }

  }
}
void BinaryFile::read( const char *_semantics, int _chunks,
                       void* _buf, size_t& _bytesRead )
{
  pDataSemantics comp = compileSemantics( _semantics );
  fread( _buf, comp->totalSize, _chunks, this->handle() );
  if ( byteorder != NATIVE_BYTEORDER )
  {
    for ( int i = 0; i < _chunks; ++i )
    {
      convert_data( comp, (char*)_buf+i*comp->totalSize );
    }
  }
  _bytesRead = comp->totalSize*_chunks;
  delete comp;
}
void BinaryFile::read( const char *_semantics,
                       void* _buf, size_t& _bytesRead )
{
  pDataSemantics comp = compileSemantics( _semantics );
  fread( _buf, comp->totalSize, 1, this->handle() );

  if ( byteorder != NATIVE_BYTEORDER )
  {
    convert_data( comp, _buf );
  }
  delete comp;
}

void BinaryFile::write( const char *_semantics,
                        void* _buf, size_t& _bytesWritten )
{
  pDataSemantics comp = compileSemantics( _semantics );
  if ( byteorder != NATIVE_BYTEORDER )
  {
    convert_data( comp, _buf );
  }
  _bytesWritten = comp->totalSize;
  fwrite( _buf, comp->totalSize, 1, this->handle() );
  delete comp;
}