RawFileParser.cpp

Go to the documentation of this file.

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>   // Mem Map Header

#include <vector>

#include "DAQDataFormats/DAQDataFormats.h"
#include "DAQDataFormats/RawRun.h"
#include "DAQDataFormats/RawRunHeader.h"
#include "DAQDataFormats/RawEvent.h"
#include "DAQDataFormats/RawEventHeader.h"
#include "DAQDataFormats/RawTrigger.h"
#include "DAQDataFormats/RawMicroBlock.h"
#include "DAQDataFormats/RawNanoSlice.h"
#include "DAQDataFormats/RawConfigurationBlock.h"

#include "RawFileParser/RawFileParser.h"

#pragma GCC diagnostic ignored "-Wformat="

#ifndef TRUE
#define TRUE   1
#endif /* TRUE */

#ifndef FALSE
#define FALSE  0
#endif /* FALSE */

#ifndef FAIL
#define FAIL  -1
#endif /* FAIL */

using namespace rawfileparser;
using namespace daqdataformats;

#define DEBUGMSG(...) if(debug_flag){fprintf(stderr, __VA_ARGS__);}


const char* RawFileParser::filetypes[] = {
  "No File open",
  "NOvA Run File",
  "NOvA Event File",
  "NOvA File, Corrupted",
  "Unknown File Type"
};



RawFileParser::RawFileParser()
  :
  fileopenned(false),
  infile(-1),
  infilename(0),
  filetype(NO_FILE),
  fileversion(0),
  memmap_io_flag(true),
  header_start(-1),
  first_event(-1),
  config_block_start(-1),
  config_block_end(-1),
  tail_start(-1),
  filepos(0),
  current_event_index(-1),
  indexBuilt(NO_INDEX),
  indexsize(-1),
  event_offset_list(),
  event_addr_list(),
  debug_flag(false)
{
  Init(); 
}

RawFileParser::RawFileParser(const char* filename)
  :
  fileopenned(false),
  infile(-1),
  infilename(0),
  filetype(NO_FILE),
  fileversion(0),
  memmap_io_flag(true),
  header_start(-1),
  first_event(-1),
  config_block_start(-1),
  config_block_end(-1),
  tail_start(-1),
  filepos(0),
  current_event_index(-1),
  indexBuilt(NO_INDEX),
  indexsize(-1),
  event_offset_list(),
  event_addr_list(),
  debug_flag(false)
{
  Init();
  this->open(filename);

}

RawFileParser::~RawFileParser(){
  this->close();
  if(infilename != NULL){
    free(infilename);
  }  
}

void RawFileParser::Init(){
  if(infilename != NULL){
    free(infilename);
  }

  debug_flag          = false;

  infilename          = NULL;

  memmap_io_flag      = true;
  mmfile_start        = NULL;
  mmfile_end          = NULL;
  mmfile_current      = NULL;

  header_start_addr       = NULL;
  first_event_addr        = NULL;
  config_block_start_addr = NULL;
  config_block_end_addr   = NULL;
  tail_start_addr         = NULL;

  fileopenned = false;
  infile      = -1;
  filetype    = NO_FILE;
  fileversion = 0;

  filepos     = 0;

  header_start       = -1;
  config_block_start = -1;
  config_block_end   = -1;
  first_event        = -1;
  tail_start         = -1;

  event_addr_list.clear();
  event_offset_list.clear();

  indexBuilt = NO_INDEX;
}

int RawFileParser::open(const char* filename){
  struct stat statbuff;

  // If there is a file already open, we close it
  if(fileopenned){
    this->close();
  }

  infilename = (char*)malloc(strlen(filename)+1);
  strcpy(infilename, filename);

  infile = ::open(infilename,O_RDONLY);
  
  if(!infile){
    DEBUGMSG("Failed to open file for reading: %s\n",infilename);
    Init();
    return infile;
  }else{
    DEBUGMSG("Opened file: %s for reading.\n",infilename);
    fileopenned = true;    
  }

  // Retrieve the file system statistics on the file
  if(fstat(infile,&statbuff) < 0){
    perror("fstat error");
    return -1;
  }

  // Check to make sure the file is not zero size
  if( statbuff.st_size < 1){
    // This is an empty file
    printf("Empty File.  Returned size: %Zd\n",statbuff.st_size);
    DEBUGMSG("Empty File.  Returned size: %Zd\n",statbuff.st_size);
    return -1;
  }

  // At this point the file is open.  We now want
  // to memory map the file into the address space 
  // of our library

  if(memmap_io_flag){
    
    // We set our flag to false just in case
    // we fail to setup our memory mapping correctly
    memmap_io_flag = false;
    
    if(
       (mmfile_start = mmap(NULL, statbuff.st_size, PROT_READ, MAP_SHARED, infile, 0)) == (caddr_t) -1){
      perror("mmap error on file");
    }else{
      DEBUGMSG("Mem Map Successful\n");
      memmap_io_flag  = true;                  // Mem mapped io is turned on
      mmfile_end8     = mmfile_start8 + statbuff.st_size;
      mmfile_current  = mmfile_start;
    }
  } // endif memmap_io_flag

  // Now check the file type
  if(CheckFileType() > 0){
    return filetype;
  }else{
    return FAIL;
  }

  return FAIL;
}


int RawFileParser::close(){
  struct stat statbuff;
  int ret=0;

  // First we close any memory maps we had on our file
  if(memmap_io_flag){
    if(mmfile_start != NULL){

      // First retrieve the size of the file
      if(fstat(infile, &statbuff) < 0){
        perror("fstat error");
      }
      
      if( (ret = munmap(mmfile_start, statbuff.st_size)) < 0){
        perror("Error unmapping file from memory");
      }
      
    }
  }

  if(infile > 0){
    ret = ::close(infile);
  }

  // If we were able to close the file, then
  // we clean up
  if(ret != 0){

    // If for some reason we were unable to close a file
    // we still clean up, but we report the error
    perror("File Close");
  }
  Init();    

  return ret;
}

int RawFileParser::CheckFileType(){
  if(memmap_io_flag){
    return CheckFileType_mem();
  }else{
    return CheckFileType_file();
  }
  return UNKNOWN_FILE;
}

int RawFileParser::CheckFileType_mem(){
  // Attempt to use memory mapped IO

    DEBUGMSG("Ussing mem\n");
    switch(mmfile_start32[0]){
      // Run File Magic
    case NOVA_ASCII:  // first word of a Run should read "NOVA" in ASCII
      switch(mmfile_start32[1]){
      case E929_ASCII:
        DEBUGMSG("NOVA Run File detected\n");
        filetype = NOVA_RUNFILE;
        break;
      default:
        DEBUGMSG("Corrupt Run File detected\n");
        filetype = CORRUPT_FILE;
        break;
      }; // endswitch word2
      break;
      // Event File Magic
    case EVENT_MARKER:  // First word of an Event should read "E929" in hex
      filetype = NOVA_EVENTFILE;
      DEBUGMSG("NOVA Event File detected\n");
      break;
    default:
      DEBUGMSG("Unrecognized NOvA File type\n");
      filetype = UNKNOWN_FILE;
      break;
    }; // endswitch word1
    
    return filetype;
}

int RawFileParser::CheckFileType_file(){
  int bytes_read = 0;
  unsigned int buff[4]={0,0,0,0};

    // First Check to make sure we have a file openned
    if(!fileopenned){
      return NO_FILE;
    }

    /* Perform some Magic Number Checking to determine the file type */
    /* To do this we allocate a small (4 word) buffer and fill it    */
    /* with the start of the file.  This allows us to do both magic  */
    /* number and version checking.  Currently only the magic is     */
    /* checked.  Will impliment file version later                   */
    
    // Read in 16 bytes of data */
    bytes_read = ::read(infile, &buff, 16);
    if(bytes_read < 0){
      // throw
    }
    
    switch(buff[0]){
      // Run File Magic
    case NOVA_ASCII:  // first word of a Run should read "NOVA" in ASCII
      switch(buff[1]){
      case E929_ASCII:
        DEBUGMSG("NOVA Run File detected\n");
        filetype = NOVA_RUNFILE;
        break;
      default:
        DEBUGMSG("Corrupt Run File detected\n");
        filetype = CORRUPT_FILE;
        break;
      }; // endswitch word2
      break;
      // Event File Magic
    case EVENT_MARKER:  // First word of an Event should read "E929" in hex
      filetype = NOVA_EVENTFILE;
      DEBUGMSG("NOVA Event File detected\n");
      break;
    default:
      DEBUGMSG("Unrecognized NOvA File type\n");
      filetype = UNKNOWN_FILE;
      break;
    }; // endswitch word1
    
    // After parsing out the file type, rewind the file
    filepos = lseek(infile, 0, SEEK_SET);
    return filetype;
}

// Method to return the file type
int RawFileParser::getFileType(){
  if(fileopenned){
    return filetype;
  }else{
    DEBUGMSG("Error retrieving file type: %s",filetypes[filetype]);
    return NO_FILE;
  }

}

/***********************************************
 * Methods that Advance around the file
 *
 ***********************************************/

int RawFileParser::AdvanceToRunHeader(off_t& header_pos){
  if(memmap_io_flag){
    return AdvanceToRunHeader_mem(header_pos);
  }else{
    return AdvanceToRunHeader_file(header_pos);
  }
  return FALSE;
}

int RawFileParser::AdvanceToRunHeader_mem(off_t& header_pos){
  int ret;
  uint32_t* start_pos;  
  off_t pos;

  RawRunHeader theHeader;

  // First see if we already have an address of the config block
  // in our cache
  if(header_start_addr != NULL){
    // Set the cached position to the current position
    mmfile_current = header_start_addr;
    pos            = mmfile_current8 - mmfile_start8;

    // Set the file position to the current position
    filepos    = rewind(pos);
    return TRUE;
  }

  // The Run header should be near the begining of the 
  // the file.  We save the current position and then
  // repostion to the start of the file
  start_pos = mmfile_current32;
  mmfile_current32 = mmfile_start32;

  bool found_block=false;
  while(!found_block){
    // Search for the first config block header word
    ret = wordsearch(theHeader.getMarkerHi());

    switch(ret){
    case TRUE:
      // Check the adjacent word  
      ++mmfile_current32;
      if(checkWord(theHeader.getMarkerLo()) > 0){found_block=true;};
      --mmfile_current32;
      break;
    case FALSE: 
      DEBUGMSG("End of file reached during run file header block start search, no header block found\n");      
      // Rewind the file to where we started from
      mmfile_current32 = start_pos;
      return FALSE;
      break;
    case FAIL:
      DEBUGMSG("Read from file failed during run header block search");
      return FAIL;
      break;
    default:
      DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",theHeader.getMarkerHi());
      return FAIL;
      break;
    } // endswitch ret
    
  } // endwhile

  // We have found our header block marker at this point

  header_start_addr = mmfile_current32;
  pos               = mmfile_current8 - mmfile_start8;

  filepos           = rewind(pos);
  header_pos        = filepos;

  return TRUE;

}

int RawFileParser::AdvanceToRunHeader_file(off_t& header_pos){
  int ret;
  off_t start_pos;

  RawRunHeader theHeader;

  // Make sure we have a file open
  if(!fileopenned){
    DEBUGMSG("AdvanceToRunHeader(): File not openned for parsing\n");
    return FALSE;
  }

  // First see if we already have an address of the config block
  // in our cache
  if(header_start > -1){
    if( rewind(header_start) < 0){
      DEBUGMSG("Unable to advance to cache position of config block start\n");
      return FAIL;
    }else{
      // Set the file position to the current position
      filepos    = curpos();
      header_pos = filepos;
      return TRUE;
    }
  }

  // Record the current file position
  if( savepos(start_pos) < 0){
    DEBUGMSG("AdvanceToRunHeader(): unable to save file position\n");
    return FAIL;
  };

  // The Run header should be near the begining of the 
  // the file so we jump to the zero offset in the file
  rewind(0);

  bool found_block=false;
  while(!found_block){
    // Search for the first config block header word
    ret = wordsearch(theHeader.getMarkerHi());

    switch(ret){
    case TRUE:
      // Check the adjacent word  
      forward(sizeof(unsigned int));
      if(checkWord(theHeader.getMarkerLo()) > 0){found_block=true;};
      backup(sizeof(unsigned int));      

      break;
    case FALSE: 
      DEBUGMSG("End of file reached during run file header block start search, no header block found\n");      
      // Rewind the file to where we started from
      rewind(start_pos);
      return FALSE;
      break;
    case FAIL:
      DEBUGMSG("Read from file failed during run header block search");
      return FAIL;
      break;
    default:
      DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",theHeader.getMarkerHi());
      return FAIL;
      break;
    } // endswitch ret
    
  } // endwhile

  // We have found our header block marker at this point

  // Record our first event point
  header_start = curpos();
  if(header_start < 0){
    return FAIL;
  }
  
  filepos         = header_start;
  header_pos      = header_start;
  return TRUE;
}



int RawFileParser::AdvanceToConfigStart(off_t& config_pos){
  if(memmap_io_flag){
    return AdvanceToConfigStart_mem(config_pos);
  }else{
    return AdvanceToConfigStart_file(config_pos);
  }
  return FALSE;
}

int RawFileParser::AdvanceToConfigStart_mem(off_t& config_pos){
  int ret;
  uint32_t* start_pos;  
  off_t pos;

  RawConfigurationHeader theConfigHeader;

  // First see if we already have an address of the config block
  // in our cache
  if(config_block_start_addr != NULL){
    // Set the cached position to the current position
    mmfile_current = config_block_start_addr;
    pos            = mmfile_current8 - mmfile_start8;

    // Set the file position to the current position
    filepos    = rewind(pos);
    config_pos = filepos;
    return TRUE;
  }

  // Save the current position before searching
  start_pos = mmfile_current32;

  bool found_block=false;
  while(!found_block){
    // Search for the first config block header word
    ret = wordsearch(theConfigHeader.getMarkerHi1());
    switch(ret){
    case TRUE:
      // Check the adjacent word  
      ++mmfile_current32;
      if(checkWord(theConfigHeader.getMarkerHi2()) > 0){found_block=true;};
      --mmfile_current32;
      break;
    case FALSE: 
      DEBUGMSG("End of file reached during config block start search, no config block found\n");      
      // Rewind the file to where we started from
      mmfile_current32 = start_pos;
      // rewind(start_pos);
      return FALSE;
      break;
    case FAIL:
      DEBUGMSG("Read from file failed during config block start search");
      return FAIL;
      break;
    default:
      DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",theConfigHeader.getMarkerHi1());
      return FAIL;
      break;
    } // endswitch ret
    
  } // endwhile

  // We have found our event block marker at this point

  config_block_start_addr = mmfile_current32;
  pos                     = mmfile_current8 - mmfile_start8;
  
  filepos                 = rewind(pos);
  config_block_start      = filepos;

  return TRUE;
}

int RawFileParser::AdvanceToConfigStart_file(off_t& config_pos){
    int ret;
  off_t start_pos;

  RawConfigurationHeader theConfigHeader;

  // Make sure we have a file open
  if(!fileopenned){
    DEBUGMSG("AdvanceToConfigStart(): File not openned for parsing\n");
    return FALSE;
  }

  // First see if we already have an address of the config block
  // in our cache
  if(config_block_start > -1){
    if( rewind(config_block_start) < 0){
      DEBUGMSG("Unable to advance to cache position of config block start\n");
      return FAIL;
    }else{
      // Set the file position to the current position
      filepos = curpos();
      config_pos = filepos;
      return TRUE;
    }
  }

  // Record the current file position
  if( savepos(start_pos) < 0){
    DEBUGMSG("AdvanceToRunStart(): unable to save file position\n");
    return FAIL;
  };

  bool found_block=false;
  while(!found_block){
    // Search for the first config block header word
    ret = wordsearch(theConfigHeader.getMarkerHi1());

    switch(ret){
    case TRUE:
      // Check the adjacent word  
      forward(sizeof(unsigned int));
      if(checkWord(theConfigHeader.getMarkerHi2()) > 0){found_block=true;};
      backup(sizeof(unsigned int));      

      break;
    case FALSE: 
      DEBUGMSG("End of file reached during config block start search, no config block found\n");      
      // Rewind the file to where we started from
      rewind(start_pos);
      return FALSE;
      break;
    case FAIL:
      DEBUGMSG("Read from file failed during config block start search");
      return FAIL;
      break;
    default:
      DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",theConfigHeader.getMarkerHi1());
      return FAIL;
      break;
    } // endswitch ret
    
  } // endwhile

  // We have found our event block marker at this point

  // Record our first event point
  config_block_start = curpos();
  if(config_block_start < 0){
    return FAIL;
  }
  
  filepos         = config_block_start;
  config_pos      = config_block_start;
  return TRUE;
}


int RawFileParser::AdvanceToConfigEnd(off_t& config_pos){
  int ret;
  off_t start_pos;

  RawConfigurationTail theConfigTail;

  // Make sure we have a file open
  if(!fileopenned){
    DEBUGMSG("AdvanceToConfigEnd(): File not openned for parsing\n");
    return FALSE;
  }

  // First see if we already have an address of the config block
  // in our cache
  if(config_block_end > -1){
    if( rewind(config_block_end) < 0){
      DEBUGMSG("Unable to advance to cache position of config block tail\n");
      return FAIL;
    }else{
      // Set the file position to the current position
      filepos = curpos();
      config_pos = filepos;
      return TRUE;
    }
  }

  // Record the current file position
  if( savepos(start_pos) < 0){
    DEBUGMSG("AdvanceToConfigEnd(): unable to save file position\n");
    return FAIL;
  };

  bool found_block=false;
  while(!found_block){
    // Search for the first config block header word
    ret = wordsearch(theConfigTail.getMarkerLo1());

    switch(ret){
    case TRUE:
      // Check the adjacent word  
      forward(sizeof(unsigned int));
      if(checkWord(theConfigTail.getMarkerLo2()) > 0){found_block=true;};
      backup(sizeof(unsigned int));      

      break;
    case FALSE: 
      DEBUGMSG("End of file reached during config block end search, no config tail found\n");      
      // Rewind the file to where we started from
      rewind(start_pos);
      return FALSE;
      break;
    case FAIL:
      DEBUGMSG("Read from file failed during config block tail search");
      return FAIL;
      break;
    default:
      DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",theConfigTail.getMarkerLo1());
      return FAIL;
      break;
    } // endswitch ret
    
  } // endwhile

  // We have found our end config block marker at this point

  // Record our config block end point
  config_block_end = curpos();
  if(config_block_end < 0){
    return FAIL;
  }
  
  filepos         = config_block_end;
  config_pos      = config_block_end;
  return TRUE;
}

int RawFileParser::AdvanceToRunTail(off_t& tail_pos){
  if(memmap_io_flag){
    return AdvanceToRunTail_mem(tail_pos);
  }else{
    return AdvanceToRunTail_file(tail_pos);
  }
  return FALSE;
}

int RawFileParser::AdvanceToRunTail_mem(off_t& tail_pos){
  int ret;
  uint32_t* start_pos;
  off_t pos;

  // First see if we already have an address of the tail 
  // event in our cache 
  if(tail_start_addr != NULL){
    // Set the cached position to the current position
    mmfile_current = tail_start_addr;
    pos            = mmfile_current8 - mmfile_start8;

    // Set the file position to the current position
    filepos    = rewind(pos);
    return TRUE;
  }

  start_pos        = mmfile_current32;   // Record the current position

  mmfile_current32 = mmfile_end32;       // Jump to the end of the file buffer
  mmfile_current32 -= 400;               // Back off from the end by 400 words

  ret = wordsearch(TAIL_MARKER);         // Look for the TAIL_MARKER

  switch(ret){
  case TRUE:
    // Check the adjacent word
    mmfile_current32++;
    checkWord(TAIL_MARKER);
    mmfile_current32--;
    break;
  case FALSE: 
    DEBUGMSG("End of file reached during run tail search, no tail found\n");      
    // Rewind the file to where we started from
    mmfile_current32 = start_pos;
    return FALSE;
    break;
  case FAIL:
    DEBUGMSG("Read from file failed during run tail search");
    return FAIL;
    break;
  default:
    DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",TAIL_MARKER);
    return FAIL;
    break;
  }

  tail_start_addr  = mmfile_current32;
  pos              = mmfile_current8 - mmfile_start8;

  filepos          = rewind(pos);
  tail_start       = filepos;

  return true;
}

int RawFileParser::AdvanceToRunTail_file(off_t& tail_pos){
  int ret;
  off_t start_pos;

  RawRunHeader theTail;

  // Make sure we have a file open
  if(!fileopenned){
    DEBUGMSG("AdvanceToRunTail(): File not openned for parsing\n");
    return FALSE;
  }

  // First see if we already have an address of the config block
  // in our cache
  if(tail_start > -1){
    if( rewind(tail_start) < 0){
      DEBUGMSG("Unable to advance to cache position of run tail\n");
      return FAIL;
    }else{
      // Set the file position to the current position
      filepos = curpos();
      tail_pos = filepos;
      return TRUE;
    }
  }

  // Record the current file position
  if( savepos(start_pos) < 0){
    DEBUGMSG("AdvanceToRunTail(): unable to save file position\n");
    return FAIL;
  };

  bool found_block=false;
  while(!found_block){
    // Search for the tail block header word
    ret = wordsearch(TAIL_MARKER);

    switch(ret){
    case TRUE:
      // Check the adjacent word  
      forward(sizeof(unsigned int));
      if(checkWord(TAIL_MARKER) > 0){found_block=true;};
      backup(sizeof(unsigned int));      

      break;
    case FALSE: 
      DEBUGMSG("End of file reached during run tail search, no tail found\n");      
      // Rewind the file to where we started from
      rewind(start_pos);
      return FALSE;
      break;
    case FAIL:
      DEBUGMSG("Read from file failed during run tail search");
      return FAIL;
      break;
    default:
      DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",TAIL_MARKER);
      return FAIL;
      break;
    } // endswitch ret
    
  } // endwhile

  // We have found our end config block marker at this point

  // Record our config block end point
  tail_start = curpos();
  if(tail_start < 0){
    return FAIL;
  }
  
  filepos         = tail_start;
  tail_pos        = tail_start;
  return TRUE;
}


// This function advances us to the first event in a file
// This function should only be used to find the FIRST 
// event, not to skip to subsequent events.
int RawFileParser::AdvanceToFirstEvent(off_t& first_event_pos, bool index_entries){
  if(memmap_io_flag){
    return AdvanceToFirstEvent_mem(first_event_pos, index_entries);
  }else{
    return AdvanceToFirstEvent_file(first_event_pos, index_entries);
  }
  return FALSE;
}

int RawFileParser::AdvanceToFirstEvent_mem(off_t& /*first_event_pos*/, bool /*index_entries*/){
  int ret;
  uint32_t* start_pos;
  off_t pos;

  // First see if we already have an address of the fist 
  // event in our cache 
  if(first_event_addr != NULL){
    // Set the cached position to the current position
    mmfile_current = first_event_addr;
    pos            = mmfile_current8 - mmfile_start8;

    // Set the file position to the current position
    filepos    = rewind(pos);
    return TRUE;
  }

  start_pos = mmfile_current32;
  mmfile_current32 = mmfile_start32;

  ret = wordsearch(EVENT_MARKER);

  switch(ret){
  case TRUE:
    break;
  case FALSE: 
    DEBUGMSG("End of file reached during first event search, no event block found\n");      
    // Rewind the file to where we started from
    mmfile_current32 = start_pos;
    return FALSE;
    break;
  case FAIL:
    DEBUGMSG("Read from file failed during event header search");
    return FAIL;
    break;
  default:
    DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",EVENT_MARKER);
    return FAIL;
    break;
  }

  first_event_addr = mmfile_current32;
  pos              = mmfile_current8 - mmfile_start8;

  filepos          = rewind(pos);
  first_event      = filepos;

  std::vector<uint32_t*>::iterator it_addr;
  it_addr = event_addr_list.begin();
  event_addr_list.insert(it_addr, 0, (uint32_t*)first_event_addr);

  std::vector<off_t>::iterator it_offset;
  it_offset = event_offset_list.begin();
  event_offset_list.insert(it_offset,0,first_event);

  indexBuilt = PARTIAL_INDEX;
  return true;

}

int RawFileParser::AdvanceToFirstEvent_file(off_t& first_event_pos, bool index_entries){
  int ret;
  off_t start_pos;

  // Make sure we have a file open
  if(!fileopenned){
    DEBUGMSG("AdvanceToFirstEvent(): File not openned for parsing\n");
    return FALSE;
  }

  // First see if we already have an address of the first
  // event in our cache
  if(first_event > -1){
    DEBUGMSG("Using Cached position of first event\n");
    if( rewind(first_event) < 0){
      DEBUGMSG("Unable to advance to cache position of first event\n");
      return FAIL;
    }else{
      // Set the file position to the current position
      filepos = curpos();
      first_event_pos = first_event;
      return TRUE;
    }
  }

  // Record the current file position
  if( savepos(start_pos) < 0){
    DEBUGMSG("wordsearch(): unable to save file position\n");
    return FAIL;
  };

  // At this point we have no idea where in the file we might be
  // but we also know that we have not yet found the first event's
  // position.  The safest thing to do is to backup to the start of 
  // the file and do a hard search from there
  
  // Rewind to the start of the file
  rewind(0);

  // Do a hard search for the first event
  ret = wordsearch(EVENT_MARKER);
  
  switch(ret){
  case TRUE:
    break;
  case FALSE: 
    DEBUGMSG("End of file reached during first event search, no event block found\n");      
    // Rewind the file to where we started from
    rewind(start_pos);
    return FALSE;
    break;
  case FAIL:
    DEBUGMSG("Read from file failed during event header search");
    return FAIL;
    break;
  default:
    DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",EVENT_MARKER);
    return FAIL;
    break;
  }

  // We have found our event block marker at this point

  // Record our first event point
  first_event = curpos();
  if(first_event < 0){
    return FAIL;
  }
  
  // Set the file position to the current position
  if(index_entries){
    // Put the event on the list
    event_offset_list.push_back(first_event);
    indexBuilt = PARTIAL_INDEX;
  }

  filepos         = first_event;
  first_event_pos = first_event;
  return TRUE;
}


int RawFileParser::AdvanceToPreviousEvent(off_t& next_event_pos, bool index_entries){
  if(memmap_io_flag){
    return AdvanceToPreviousEvent_mem(next_event_pos, index_entries);
  }else{
    //    return AdvanceToNextEvent_file(next_event_pos, index_entries);
    return FALSE;
  }
  return FALSE;
}

int RawFileParser::AdvanceToPreviousEvent_mem(off_t& next_event_pos, bool index_entries){
  int ret;
  uint32_t* start_pos;
  off_t pos;

  // Save the current position
  start_pos = mmfile_current32;

  // Now check that we are starting on an event boundary
  ret = checkWord(EVENT_MARKER);

  if(ret < 0){
    // Something went wrong, return back an error
    return FAIL;
  }

  // We force the direct reverse search
  ret = 0;

  if(ret == 0){
    // For some reason our current position doesn't appear to
    // be an event start boundary.  We move backwards with
    // a direct word by word search
    DEBUGMSG("trying reverse direct...");

    --mmfile_current32;
    switch(wordsearchreverse(EVENT_MARKER)){
    case TRUE:
      break;
    case FALSE: 
      DEBUGMSG("AdvanceToPreviousEvent(): End of file reached during event search, no event block found\n");      
      // Rewind the file to where we started from
      mmfile_current32 = start_pos;
      return FALSE;
      break;      
    case FAIL:
      DEBUGMSG("AdvanceToPreviousEvent(): Read from file failed during event header search");
      return FAIL;
      break;
    default:
      DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",EVENT_MARKER);
      return FAIL;
      break;
    }
    // We have found our next event
  }

  // Calculate the offset
  pos = mmfile_current8 - mmfile_start8;
  
  // Check the offset to make sure something moved
  if(pos != 0) {
    return TRUE;
  }else{
    return FALSE; 
  }

  return FALSE;
}


// This function advances us to the next event in a file.
// It is assumed when calling this function that the
// entry point that we are sitting is an event record 
// so that we can just jump ahead by the size of the record
// There is limited checking though so it can move forward 
// byte by byte looking for an event if it has problems
// with the direct jump. (i.e. file is damaged)
int RawFileParser::AdvanceToNextEvent(off_t& next_event_pos, bool index_entries){
  if(memmap_io_flag){
    return AdvanceToNextEvent_mem(next_event_pos, index_entries);
  }else{
    return AdvanceToNextEvent_file(next_event_pos, index_entries);
  }
  return FALSE;
}

int RawFileParser::AdvanceToNextEvent_mem(off_t& next_event_pos, bool index_entries){
  int ret;
  uint32_t* start_pos;
  off_t pos;

  // Save the current position
  start_pos = mmfile_current32;

  // Now check that we are starting on an event boundary
  ret = checkWord(EVENT_MARKER);

  if(ret < 0){
    // Something went wrong, return back an error
    return FAIL;
  }
  
  if(ret == 0){
    // For some reason our current position doesn't appear to
    // be an event start boundary.  We move forward with
    // a direct word by word search
    DEBUGMSG("trying direct...");

    switch(wordsearch(EVENT_MARKER)){
    case TRUE:
      break;
    case FALSE: 
      DEBUGMSG("AdvanceToNextEvent(): End of file reached during event search, no event block found\n");      
      // Rewind the file to where we started from
      mmfile_current32 = start_pos;
      return FALSE;
      break;      
    case FAIL:
      DEBUGMSG("AdvanceToNextEvent(): Read from file failed during event header search");
      return FAIL;
      break;
    default:
      DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",EVENT_MARKER);
      return FAIL;
      break;
    }
    // We have found our next event
  }

  if(ret > 0){
    // We appear to be on a standard event start boundary
    // We try to advance forward in a smart fashion by 
    // reading the event size and jumping ahead
    ssize_t eventsize;
    
    // First retrieve the size of the current event
    eventsize = readEventSize();
    // DEBUGMSG("Size: 0x%08Zx\t%Zd\n",eventsize,eventsize);

    if(eventsize < 0){
      DEBUGMSG("Unable to retrieve event size in AdvanceToNextEvent()\n");
      return FAIL;
    }
    
    // Now skip ahead in the file by the event size
    mmfile_current32 += eventsize;
    
    // Check to see that we are NOW on an event header boundary
    if( checkWord(EVENT_MARKER) != TRUE){      
      DEBUGMSG("Error in advancing to next event in AdvanceToNextEvent()\n");
    }else{
      // We have found the next event so we set the position and return
      filepos = curpos();
      next_event_pos = curpos();
      return TRUE;
    }
        
    // Check to see that we are NOW on an event header boundary
    if( checkWord(EVENT_MARKER) != TRUE){
      // We don't appear to be on the right boundary
      // we are going to back up and try to locate the next event
      // via direct search
      mmfile_current32 = start_pos+1;

      switch(wordsearch(EVENT_MARKER)){
      case TRUE:
        break;
      case FALSE: 
        DEBUGMSG("AdvanceToNextEvent(): End of file reached during event search, no event block found\n");      
        // Rewind the file to where we started from
        mmfile_current32 = start_pos;
        return FALSE;
        break;      
      case FAIL:
        DEBUGMSG("AdvanceToNextEvent(): Read from file failed during event header search");
        return FAIL;
        break;
      default:
        DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",EVENT_MARKER);
        return FAIL;
        break;
      }
      
      // DEBUGMSG("Error in advancing to next event in AdvanceToNextEvent()\n");
    }

  } /* endif ret */

  // We have found our next event
  
  // Calculate the offset
  pos = mmfile_current8 - mmfile_start8;
  
  // Record it on our event list index
  if(index_entries){      
    event_addr_list.push_back(mmfile_current32);
    event_offset_list.push_back(pos);
    indexBuilt = PARTIAL_INDEX;
  }
  
  // Move the file to this offset
  filepos = rewind(pos);
  next_event_pos = pos;    
  
  return TRUE;
}

int RawFileParser::AdvanceToNextEvent_file(off_t& next_event_pos, bool index_entries){

  int          ret;
  off_t        start_pos;
  ssize_t      eventsize;

  // Make sure we have a file open
  if(!fileopenned){
    DEBUGMSG("AdvanceToNextEvent(): File not openned for parsing\n");
    return FALSE;
  }
  
  // First save our position in the file
  if( savepos(start_pos) < 0){
    DEBUGMSG("AdvanceToNextEvent(): unable to save file position\n");
    return FAIL;
  }

  // Now check that we are starting on an event boundary
  ret = checkWord(EVENT_MARKER);

  if(ret < 0){
    // Something went wrong, return back an error
    return FAIL;
  }
  
  if(ret == 0){
    // For some reason our current position doesn't appear to
    // be an event start boundary.  We move forward with
    // a direct word by word search
    
    switch(wordsearch(EVENT_MARKER)){
    case TRUE:
      break;
    case FALSE: 
      DEBUGMSG("AdvanceToNextEvent(): End of file reached during event search, no event block found\n");      
      // Rewind the file to where we started from
      rewind(start_pos);
      return FALSE;
      break;      
    case FAIL:
      DEBUGMSG("AdvanceToNextEvent(): Read from file failed during event header search");
      return FAIL;
      break;
    default:
      DEBUGMSG("Unknown error in wordsearch(0x%08x)\n",EVENT_MARKER);
      return FAIL;
      break;
    }

    if(index_entries){
      // We have found our next event
      // Record it on our event list
      event_offset_list.push_back(curpos());
      indexBuilt = PARTIAL_INDEX;
    }

    // Set the file position to the current position
    filepos = curpos();
    next_event_pos = curpos();
    return TRUE;
  } /* endif ret == 0 */

  if(ret > 0){
    // We appear to be on a standard event start boundary
    // We try to advance forward in a smart fashion by 
    // reading the event size and jumping ahead
    
    // First retrieve the size of the current event
    eventsize = readEventSize();
    if(eventsize < 0){
      DEBUGMSG("Unable to retrieve event size in AdvanceToNextEvent()\n");
      return FAIL;
    }
    
    // Now skip ahead in the file by the event size
    if( forward(eventsize) < 0){
      perror("Unable to advance file in AdvanceToNextEvent()");
    }
    
    // Check to see that we are NOW on an event header boundary
    if( checkWord(EVENT_MARKER) != TRUE){
      DEBUGMSG("Error in advancing to next event in AdvanceToNextEvent()\n");
    }else{
      // We have found the next event so we set the position and return
      filepos = curpos();
      next_event_pos = curpos();
      return TRUE;
    }
  } /* endif ret */

  return FALSE;
}

// Method to advance to an event (and tries to be smart 
// depending on where we are in the file)
int RawFileParser::AdvanceToEvent(off_t& event_pos, bool index_entries){

  // Make sure we have a file open
  if(!fileopenned){
    DEBUGMSG("AdvanceToNextEvent(): File not openned for parsing\n");
    return FALSE;
  }

  // Check to see if we have located our first event
  if(isMemoryMappedIO()){
    if(first_event_addr == NULL){
      return AdvanceToFirstEvent(event_pos, index_entries);
    }else{
      return AdvanceToNextEvent(event_pos, index_entries);
    }
  }else{
    if(first_event == -1){
      // We haven't found our first event yet, so we default
      // to the finding it the safe way
      return AdvanceToFirstEvent(event_pos, index_entries);
    }

    // If we are at a position before the first event
    // we move to the first event
    if(first_event > filepos){
      return AdvanceToFirstEvent(event_pos, index_entries);
    }

    // If we are at or after the first event, 
    // we go to the Next event
    if(first_event <= filepos){
      return AdvanceToNextEvent(event_pos, index_entries);
    }
  }
  return FAIL;
}

int RawFileParser::GotoEvent(int event_no){
  if(isMemoryMappedIO()){
    return GotoEvent_mem(event_no);
  }else{
    return GotoEvent_file(event_no);
  }
  return FAIL;
}

int RawFileParser::GotoEvent_mem(int event_no){
  static int recursion_depth=0;

  recursion_depth++;
  if(recursion_depth > 2){return FAIL;}

  if(indexBuilt == FULL_INDEX){
    if((unsigned int)event_no < event_addr_list.size()){
      mmfile_current32 = event_addr_list[event_no];
      recursion_depth = 0;
      return TRUE;
    }else{
      DEBUGMSG("GotoEvent_mem(): Requested index exceeds maximum event in file\n");
      recursion_depth = 0;
      return FALSE;
    }    
  }else{
    // We don't have a full index so we attempt to index
    // the file and then return the events
    BuildEventIndex_mem(-1,true);
    return GotoEvent_mem(event_no);
  }
  recursion_depth = 0;
  return FALSE;
}

int RawFileParser::GotoEvent_file(int event_no){
  off_t evtpos;
  int   ret;

  // Make sure we have a file open
  if(!fileopenned){
    DEBUGMSG("GotoEvent(): File not openned for parsing\n");
    return FALSE;
  }

  // First check to see if we have an index built
  switch(indexBuilt){
  case FULL_INDEX:
    // If we have a full index, then we try to just go directly
    // to the event of interest
    if( (unsigned)event_no <= event_offset_list.size()){
      if( rewind(event_offset_list[event_no] <0)){
        DEBUGMSG("Error going to event: %d under current index\n",event_no);
        return FAIL;
      }else{
        // Set the file position to the current position
        filepos = curpos();
        return TRUE;
      }
    }else{
      DEBUGMSG("Requested event number: %d, exceeds maximum number of events in index\n",event_no);
      return FALSE;
    }
    break;

  case NO_INDEX:
    // If we have no index and we were asked to goto an event,
    // we have to do it the painful way, one event at a time
    // we do however build the index as we go so at least
    // the next time we can jump around
    for(int num_events=0; num_events<event_no; ++num_events){
      ret = AdvanceToEvent(evtpos,true);
      if(ret == TRUE){continue;}
      if(ret == FALSE){
        // We have reached the end of the file but not yet found the event
        indexsize  = num_events;
        indexBuilt = FULL_INDEX;
        // Since we didn't find the event we return false
        evtpos = 0;
        return FALSE;
      }
      if(ret == FAIL){
        // Something failed
        evtpos = 0;
        return FAIL;
      }
    } // endif i
    // We have advanced to our event successfully
    return TRUE;
    break;

  case PARTIAL_INDEX:
    // We have a partial index, so we jump directly as far as we can
    // and then after that we step event by event
    if(event_no <= indexsize){
      // we can jump directly to our event
      rewind(event_offset_list[event_no]);
      filepos = event_offset_list[event_no];
    }
    
    if(event_no > indexsize){
      // First jump to the last position we have indexed
      rewind(event_offset_list[event_offset_list.size()]);
      current_event_index = event_offset_list.size();
      filepos = event_offset_list[event_offset_list.size()];

      // Now pickup at this point and step forward
      for(int num_events= event_offset_list.size(); num_events<event_no; ++num_events){
        ret = AdvanceToEvent(evtpos,true);
        if(ret == TRUE){continue;}
        if(ret == FALSE){
          // We have reached the end of the file but not yet found the event
          indexsize  = num_events;
          indexBuilt = FULL_INDEX;
          // Since we didn't find the event we return false
          evtpos = 0;
          return FALSE;
        }
        if(ret == FAIL){
          // Something failed
          evtpos = 0;
          return FAIL;
        }
      } // endif i
      // We found the event
      return TRUE;
    }
    
    break;
  } // endswitch

  return FALSE;
}

int RawFileParser::BuildEventIndex(int max_idx, bool force_rebuild){
  if(memmap_io_flag){
    return BuildEventIndex_mem(max_idx, force_rebuild);
  }else{
    return BuildEventIndex_file(max_idx, force_rebuild);
  }
  return FALSE;
}

int RawFileParser::BuildEventIndex_mem(int max_idx, bool force_rebuild){
  int ret;
  int num_events;
  off_t pos;

  // Guard against rebuilding the index
  // except when asked to do it
  if(indexBuilt==FULL_INDEX){
    if(!force_rebuild){
      return TRUE;
    }
  }

  // If we have been asked to rebuild the index
  // We don't support partial rebuilds right now
  // so we just clear the current index and rebuilt it all
  if(force_rebuild){
    event_addr_list.clear();
    indexBuilt = NO_INDEX;
    num_events = 0;

    // Goto the first event in the file
    AdvanceToFirstEvent(pos,true);
    ret = TRUE;
    while(ret  == TRUE){
      ret = AdvanceToNextEvent(pos,true);
      if(ret > 0){num_events++;}
    }
    if(ret == FALSE){indexBuilt = FULL_INDEX; return TRUE;}
    if(ret == FAIL){indexBuilt  = PARTIAL_INDEX; return FALSE;}
  }  
  return FALSE;
}

int RawFileParser::BuildEventIndex_file(int max_idx, bool force_rebuild){
  int ret;
  int num_events;
  off_t current_event_position;

  // Guard against rebuilding the index
  // except when asked to do it
  if(indexBuilt==FULL_INDEX){
    if(!force_rebuild){
      return TRUE;
    }
  }

  if(force_rebuild){
    event_offset_list.clear();
    indexBuilt = NO_INDEX;
    num_events = 0;
  }else{
    num_events = current_event_index;
  }

  // Now go and build the index  
  while(true){
    ret = AdvanceToEvent(current_event_position,true);
    
    if(ret == TRUE){
      ++num_events;
      indexBuilt = PARTIAL_INDEX;
      continue;
    }

    if(ret == 0){
      // We have reached the end of the file and should have 
      // all the events indexed
      indexsize  = num_events;
      indexBuilt = FULL_INDEX;
      return TRUE;
    }

    if(ret < 0){
      // An error occured
      DEBUGMSG("Error Building event index at event %d\n",num_events+1);
      return FAIL;
    }
    
    // If we were requested to do only a partial rebuild
    // check the indexing here
    if(max_idx > 0){
      if(num_events > max_idx){return TRUE;}
    }

  } // endwhile

  return FALSE;
}

ssize_t RawFileParser::readEventSize(bool freemem_flag){
  if(memmap_io_flag){
    return readEventSize_mem(freemem_flag);
  }else{
    return readEventSize_file(freemem_flag);
  }
  return FAIL;
}
ssize_t RawFileParser::readEventSize_mem(bool freemem_flag){
  // With the memory mapped IO method we don't need 
  // to worry about allocating any buffers
  RawEventHeader theHeader;
  
  // Ensure that we are on a current event boundary
  if(checkWord(EVENT_MARKER) != TRUE){
    return -1;
  }

  // Set the event to point at the current position in the
  // memory mapped file
  theHeader.setBufferSource(mmfile_current32);

  // Return the size of the event
  return theHeader.getEventSize();
}

ssize_t RawFileParser::readEventSize_file(bool freemem_flag){
  int bytes_read;
  uint32_t event_size;
  static unsigned char* header_buff=NULL;     // Buffer pointer for 8bit aligned header data

  RawEventHeader theHeader;

  // Allocate a memory buffer for the header read
  if(header_buff == NULL){
    header_buff = (unsigned char*) malloc(theHeader.sizeofdata()*sizeof(uint32_t));
  }

  // Assume that the current seek point of the 
  // file descriptor points to the start of a RawEvent
  bytes_read = ::read(infile, header_buff, theHeader.sizeofdata()*sizeof(uint32_t));

  // Check for end of file or read error
  if(bytes_read < 0){
    // We have a read error
    perror("File read error during event header read");
    return FAIL;
  }

  if(bytes_read == 0){
    // We have reached the end of the file
    DEBUGMSG("End of file reached during event header read");
    return FALSE;
  }

  // Check for incomplete reads  
  if(bytes_read != (int)(theHeader.sizeofdata()*sizeof(uint32_t))){
    perror("Incomplete read encountered while reading event header");
    return FAIL;
  }
  
  // Point the header to the input buffer we just filled
  theHeader.setBufferSource(header_buff);
  
  // We extract the full event size
  event_size = theHeader.getEventSize();

  // Rewind our read point
  backup(bytes_read);

  // If we were passed the flag to cleanup our memory
  // buffer, we free it now
  if(freemem_flag){
    if(header_buff != NULL){
      free(header_buff);
    }
  }

  // Return the size of the event in bytes
  return (event_size)*(sizeof(uint32_t));

}

// 
// Utility functions to search for a given 32bit word
//
int RawFileParser::wordsearch(unsigned int searchword){
  if(memmap_io_flag){
    return wordsearch_mem(searchword);
  }else{
    return wordsearch_file(searchword);
  }
  return FALSE;
}

int RawFileParser::wordsearchreverse(unsigned int searchword){
  if(memmap_io_flag){
    return wordsearchreverse_mem(searchword);
  }else{
    //    return wordsearch_file(searchword);
    return FALSE;
  }
  return FALSE;
}

int RawFileParser::wordsearch_mem(unsigned int searchword){
  uint32_t* start_pos;
  bool notfound = true;

    DEBUGMSG("Current is %p, end of file is %p, and start is %p\n", mmfile_current32, mmfile_end32, mmfile_start32)
  start_pos = mmfile_current32;
  if(start_pos < mmfile_start32) {
    start_pos = mmfile_start32;
    mmfile_current32 = mmfile_start32;
  }

  while(notfound){ ;
    if(mmfile_current32 >= mmfile_end32){
      DEBUGMSG("End of file reached, no event block found\n");
      mmfile_current32 = start_pos;
      return FALSE;
    }
    
    if(*mmfile_current32 == searchword){
      notfound = false;
      return TRUE;
    }
    
    if(mmfile_current32 < mmfile_end32){
      ++mmfile_current32;
    }
    
  } // endwhile

  return FALSE;
}

int RawFileParser::wordsearchreverse_mem(unsigned int searchword){
  uint32_t* start_pos;
  bool notfound = true;

  start_pos = mmfile_current32;

  while(notfound){ 

    if(mmfile_current32 <= mmfile_start32){
      DEBUGMSG("End of file reached, no event block found\n");
      mmfile_current32 = start_pos;
      return FALSE;
    }
    
    if(*mmfile_current32 == searchword){
      notfound = false;
      return TRUE;
    }
    
    if(mmfile_current32 < mmfile_end32){
      --mmfile_current32;
    }
    
  } // endwhile

  return FALSE;
}

int RawFileParser::wordsearch_file(unsigned int searchword){

  // Make sure we have a file open
  if(!fileopenned){
    DEBUGMSG("wordsearch(): File not openned for parsing\n");
    return FALSE;
  }

  off_t        start_pos;
  // Record the current file position
  if( savepos(start_pos) < 0){
    DEBUGMSG("wordsearch(): unable to save file position\n");
    return FAIL;
  };
  
  int          bytes_read = -1;
  unsigned int buff       = 0;
  /// Need to make sure that it's going to start search
  if(buff == searchword) buff = searchword + 1;
  // Parse through the file from the current position
  // look for the searchword
  while(buff != searchword){
    bytes_read = ::read(infile, &buff, sizeof(int));

    // Check for errors on the read
    switch(bytes_read){
    case -1:
      perror("Read from file failed during event header search");
      rewind(start_pos);
      return FAIL;
      break;
    case 0: 
      DEBUGMSG("End of file reached, no event block found\n");
      
      // Rewind the file to where we started from
      rewind(start_pos);
      return FALSE;
      break;
    default:
      // Our read returned the right number of bytes so we
      // continue to the next block
      break;
    }// end of switch

  } // endwhile

  // We have found our search word.  Hurrah!

  // Rewind the current file pointer by 4 bytes to position
  // it at the start of the event block
  if( backup(bytes_read) < 0 ){
    DEBUGMSG("Unable to rewind file in wordsearch()\n");
    return FAIL;
  };

  // Set the file position to the current position
  filepos = curpos();

  // Return success
  return TRUE;

}

int RawFileParser::checkWord(unsigned int testword){
  if(memmap_io_flag){
    return checkWord_mem(testword);
  }else{
    return checkWord_file(testword);
  }
  return FALSE;
}

int RawFileParser::checkWord_mem(unsigned int testword){
  // Guard against going out of bounds on the memory map
  if(mmfile_current32 > (mmfile_end32 - 1)){ return FAIL;}

  if(*mmfile_current32 == testword){
    return TRUE;
  }else{
    return FALSE;
  }
  return FALSE;
}

int RawFileParser::checkWord_file(unsigned int testword){
  unsigned int buff;
  int          bytes_read;

    bytes_read = ::read(infile, &buff, sizeof(unsigned int));
    
    // Check for errors on the read
    switch(bytes_read){
    case -1:
      perror("Read Failed during checkWord()");
      return FAIL;
      break;
    case 0: 
      DEBUGMSG("End of file reached during checkWord()\n");
      return FAIL;
      break;
    default:
      // Our read returned the right number of bytes so we
      // continue to the next block
    break;
    }
    
    // rewind back to where we started
    if(backup(bytes_read) < 0){
      perror("Unable to rewind file in checkWord()");
      return FAIL;
    }
    
    if( buff == testword){
      return TRUE;
    }else{
      return FALSE;
    }    
    return FALSE;
}

off_t RawFileParser::savepos(off_t& position){
  position = lseek(infile, 0, SEEK_CUR);

  if(position < 0){
    perror("Unable to save file position, savepos()");
    position = 0;
    return -1;
  }

  return position;
}

//
// Utility Function for dumping a buffer
// 
void RawFileParser::dumpBuffer(int bytes, int col){
  int i;
  int words;

  if(isMemoryMappedIO()){    
    words = bytes/sizeof(int);
    for(i=0; i<words; ++i){
      printf("0x%08x ",mmfile_current32[i]);
      if(((i+1)%col)==0){DEBUGMSG("\n");}
    }
    printf("\n");
    return;
  }

}

void RawFileParser::dumpBuffer(void* buff, int bytes, int col){
  int i;
  int words;
  int* buff32;
  buff32 = (int*)buff;
  words = bytes/sizeof(int);
  for(i=0; i<words; ++i){
    printf("0x%08x ",buff32[i]);
    if(((i+1)%col)==0){DEBUGMSG("\n");}
  }
  printf("\n");
  return;
}

//
// Utility Functions for verifying buffers
// 
bool RawFileParser::checkRunHeader(void* buff){
  uint32_t* buff32;
  buff32 = (uint32_t*)buff;
  
  if((buff32[0]==NOVA_ASCII) && (buff32[1]==E929_ASCII)){
    return true;
  }else{
    return false;
  }
  return false;
}

bool RawFileParser::checkConfigStart(void* buff){
  uint32_t* buff32;
  RawConfigurationHeader theConfigHeader;

  buff32 = (uint32_t*)buff;
  
  if( (buff32[0]==theConfigHeader.getMarkerHi1()) && (buff32[1]==theConfigHeader.getMarkerHi2())){
    return true;
  }else{
    return false;
  }
  return false;
}

bool RawFileParser::checkEventHeader(void* buff){
  uint32_t* buff32;
  buff32 = (uint32_t*)buff;
  
  if(buff32[0]==EVENT_MARKER){
    return true;
  }else{
    return false;
  }
  return false;
}

bool RawFileParser::checkEvent(void* buff){
  uint32_t* buff32;
  buff32 = (uint32_t*)buff;
  
  if(buff32[0]==EVENT_MARKER){
    return true;
  }else{
    return false;
  }
  return false;
}

bool RawFileParser::checkRunTail(void* buff){
  uint32_t* buff32;
  buff32 = (uint32_t*)buff;
  
  if(buff32[0]==TAIL_MARKER){
    return true;
  }else{
    return false;
  }
  return false;
}

int RawFileParser::getRunHeader(RawRunHeader& theRunHeader){
  int ret;
  off_t pos;

  // Move to the position of the Run Header
  ret = AdvanceToRunHeader(pos);

  // Check that we found it correctly
  switch(ret){
  case TRUE:
    // Set the buffer source of the RunHeader Object to the current position
    theRunHeader.setBufferSource(mmfile_current);
    break;
  }
  return ret;
}

int RawFileParser::getRunTail(RawRunHeader& theRunTail){
  int ret;
  off_t pos;

  // Move to the position of the Run Header
  ret = AdvanceToRunTail(pos);

  // Check that we found it correctly
  switch(ret){
  case TRUE:
    // Set the buffer source of the RunHeader Object to the current position
    theRunTail.setBufferSource(mmfile_current);
    break;
  }
  return ret;
}

int RawFileParser::getConfigBlock(RawConfigurationBlock& theConfigBlock){
  int ret;
  off_t pos;

  // Move to the position of the Run Header
  ret = AdvanceToConfigStart(pos);

  // Check that we found it correctly
  switch(ret){
  case TRUE:
    // Set the buffer source of the RunHeader Object to the current position
    theConfigBlock.setBufferSource(mmfile_current);
    break;
  }
  return ret;
}

int RawFileParser::getFirstEvent(RawEvent& theEvent){
  int ret;
  off_t pos;

  // Move to the position of the Run Header
  ret = AdvanceToFirstEvent(pos);

  // Check that we found it correctly
  switch(ret){
  case TRUE:
    // Set the buffer source of the RunHeader Object to the current position
    theEvent.setBufferSource(mmfile_current);
    break;
  }
  return ret;
}

int RawFileParser::getPreviousEvent(RawEvent& theEvent){
  int ret;
  off_t pos;

  // Move to the position of the Run Header
  ret = AdvanceToPreviousEvent(pos,true);

  // Check that we found it correctly
  switch(ret){
  case TRUE:
    // Set the buffer source of the RunHeader Object to the current position
    theEvent.setBufferSource(mmfile_current);
    return TRUE;
    break;
  }
  return ret;
}

int RawFileParser::getNextEvent(RawEvent& theEvent){
  int ret;
  off_t pos;

  // Move to the position of the Run Header
  ret = AdvanceToNextEvent(pos,true);

  // Check that we found it correctly
  switch(ret){
  case TRUE:
    // Set the buffer source of the RunHeader Object to the current position
    theEvent.setBufferSource(mmfile_current);
    return TRUE;
    break;
  }
  return ret;
}

int RawFileParser::getEvent(RawEvent& theEvent){
  int ret;
  off_t pos;
  uint32_t s;
  static RawEvent tmpEvent;

  // Move to the position of the Run Header
  ret = AdvanceToEvent(pos,true);

  if(ret){
    tmpEvent.setBufferSource(mmfile_current);
    s = tmpEvent.getEventSize();
    if( (mmfile_current32+s) > mmfile_end32){
      return FALSE;
    }
  }

  // Check that we found it correctly
  switch(ret){
  case TRUE:
    // Set the buffer source of the RunHeader Object to the current position
    theEvent.setBufferSource(mmfile_current);
    return TRUE;
    break;
  }
  return ret;
}

int RawFileParser::getEvent(RawEvent& theEvent, int event_no){
  int ret;

  // Move to the position of the Run Header
  ret = GotoEvent(event_no);

  // Check that we found it correctly
  switch(ret){
  case TRUE:
    // Set the buffer source of the RunHeader Object to the current position
    theEvent.setBufferSource(mmfile_current);
    return TRUE;
    break;
  }
  return ret;
}