/cygdrive/d/src/svn/vrut/trunk/modules/tracking/info/pparser.cpp

Go to the documentation of this file.

#include "pparser.h"
#include <iostream>


PParser::PParser(char *packet, unsigned int length): mp_packet(packet), m_packet_length(length), m_packet_index(0), m_frame_counter(0)
{}
PParser::~PParser() // default destructor
{}
void PParser::setLength(unsigned int length)
{
       m_packet_length = length;
       m_packet_index =  0;
}
void PParser::setPacket(char* packet)
{
       mp_packet = packet;
}
char * PParser::getPacket()
{
       return mp_packet;
}
bool PParser::parse()
{
       State state = INIT;
// every datagram start with "fr" tag that mean framepointer
       if ('f' == mp_packet[0] && 'r' == mp_packet[1] && ' ' == mp_packet[2])
       {
              m_packet_index = 3; // set packet iterator to next number
              m_frame_counter = parse_fr();
              std::cout << parse_int();
       }
       else
       {      
              return false; // bad packet syntax!
       }

       while ( m_packet_index < m_packet_length) // while not end of the packet
       {
              char chunk =  mp_packet[m_packet_index++]; // get next chunk
              switch (state)
              {
              case INIT:
                     {
                            // changing state
                                 if ('t' == chunk) state = S1;
                            else if ('3' == chunk) state = S3;
                            else if ('g' == chunk) state = S5;
                            else if ('6' == chunk) state = S7;
                            else return false; // instead of going to error state
                            break;
                     }
              case S1:
                     {
                            if ('s' == chunk) state = S2;
                            else return false; // insted of going to error state
                            break;
                     }
              case S2:
                     {
                            if (' ' == chunk) 
                            {
                                   parse_ts(); // tag is OK - now parsing arguments of tag...
                                   state = INIT; // after parsing tag - INIT state
                            }
                            else return false; // instead of going to error state
                            break;
                     }
              case S3:
                     {
                            if ('d' == chunk) state = S4;
                            else return false;
                            break;
                     }
              case S4:
                     {
                            if (' ' == chunk)
                            {
                                   parse_3DOF(); // tag OK - parse rest of line
                                   state = INIT; // try to fing another parser
                            }
                            else return false;
                            break; 
                     }
              case S5:
                     {
                            if ('l' == chunk) state = S6;
                            else return false;
                            break;
                     }
              case S6:
                     {
                            if (' ' == chunk)
                            {
                                   parse_gl();
                                   state = INIT;
                            }
                            else return false;
                            break;
                     }
              case S7:
                     {
                            if ('d' == chunk) state = S8;
                            else return false;
                            break;
                     }
              case S8:
                     {
                                 if ('f' == chunk) state = S9;
                            else if ('c' == chunk) state = S11;
                            else if (' ' == chunk)
                            {
                                   parse_6DOF();
                                   state = INIT;
                            }
                            else return false;
                            break;
                     }
              case S9:
                     {
                            if ('2' == chunk) state = S10;
                            else if (' ' == chunk)
                            {
                                   parse_flystick();
                                   state = INIT;
                            }
                            else return false;
                            break;
                     }
              case S10:
                     {
                            if (' ' == chunk)
                            {
                                   parse_flystick2();
                                   state = INIT;
                            }
                            else return false;
                            break;
                     }
              case S11:
                     {
                            if ('a' == chunk) state = S12;
                            else return false;
                            break;
                     }
              case S12:
                     {
                            if ('l' == chunk) state = S13;
                            else return false;
                            break;
                     }
              case S13:
                     {
                            if (' ' == chunk)
                            {
                                   parse_6dcal();
                                   state = INIT;
                            }
                            else return false;
                            break;
                     }
              default: return false; // Also error state- if ERR or undefined state - parsing unsuccesfull
              }
       }
       return true;
}
unsigned int PParser::parse_fr()
{
       // TODO:: Implement
       return 0;
}
void PParser::parse_ts()
{
       // TODO:: Implement
}
void PParser::parse_3DOF()
{
       // TODO:: Implement
}
void PParser::parse_gl()
{
       // TODO:: Implement
}
void PParser::parse_6DOF()
{
       // TODO:: Implement
}
void PParser::parse_flystick()
{
       // TODO:: Implement
}
void PParser::parse_flystick2()
{
       // TODO:: Implement
}
void PParser::parse_6dcal()
{
       // TODO:: Implement
}

int PParser::parse_int()
{
       // TODO:: rebulid this method
       int tmp = 0;
       char chunk =  mp_packet[m_packet_index++];
       while('0' <= chunk && '9' >= chunk)
       {
              if (m_packet_index >= m_packet_length) return 0; 
              tmp = tmp * 10 + (int)(chunk - '0');
              chunk =  mp_packet[m_packet_index++];
       }
       return tmp;
}


int main()
{
              char * aa = "fr 45632f";
       PParser parser;
       parser.setLength(7);
       parser.setPacket(aa);
       parser.parse();

       
return 0;
}

---