_string_token.cpp

蓝牙芯片ZV4301的调试工具源码.做蓝牙产品时很有参考价值内部有串口的编程序源码,对有串口编成需求的同志有参考价值.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "_string_token.h"

TStringToken::TStringToken(char *string)
{
  msg_count = 0;
  msg = NULL;
  //data = NULL;
  if(string){
      data = (char *)malloc(strlen(string) + 1);
      strcpy(data, string);
      analyze();
  }

}

TStringToken::~TStringToken()
{
  if(data)
    free(data);
  clear_msg();
}

void TStringToken::analyze(void)
{
  int len = strlen(data);
  for(int i = 0; i< len;)
  {
    if(data[i] == ' ' || data[i] == '\t')
      i++; //Skip
    else if(data[i] == '%')
      break;  //Stop parsing
    else
    {
      TToken *newmsg;
      int end, start = i;
      for(;data[i] != ' ' && data[i] != '%'  && data[i] != '\t' && i< len;i++)
        end = i;
      newmsg = AddMsg(end - start + 1);
      newmsg->offset = start;
      memcpy(newmsg->data, &data[start], end - start + 1);
      if(newmsg->bytes > 1)
       analyze_msg(newmsg);
    }
  }
}

void TStringToken::analyze_msg(TToken* target)
{
  if(target)
  {
    for(int i=0; i<target->bytes && target->bytes > 1; i++)
    {
      if(target->data[i] == ',' ||
         target->data[i] == ';' ||
         target->data[i] == '>' ||
         target->data[i] == '@')
      {
        TToken *newmsg;
        if(i)
        {
          newmsg = AddMsg(target->bytes - i);
          strcpy(newmsg->data, &target->data[i]);
          update_msg(target, &target->data[0], i);
          newmsg->offset = target->offset + i;
        }
        else
        {
          newmsg = AddMsg(target->bytes - 1);
          strcpy(newmsg->data, &target->data[1]);
          update_msg(target, &target->data[0], 1);
          newmsg->offset = target->offset + 1;
        }
        i = -1;
        target = target->next;
      }
    }
  }
}

TToken* TStringToken::AddMsg(unsigned __int32 bytes)
{

  if(msg)
  {
    TToken **find_last = &msg;

    while((*find_last)->next)
      find_last = &((*find_last)->next);

    (*find_last)->next = (TToken *)malloc(sizeof(TToken));
    (*find_last)->next->index = msg_count;
    (*find_last)->next->data = (char *)malloc(bytes + 1);
    memset((*find_last)->next->data, 0, bytes + 1);
    (*find_last)->next->next = NULL;
    (*find_last)->next->bytes = bytes;
    (*find_last)->next->last = (*find_last);
    msg_count++;
    return (*find_last)->next;
  }
  else
  {
    msg = (TToken *)malloc(sizeof(TToken));
    msg->index = msg_count;
    msg->data = (char *)malloc(bytes + 1);
    memset(msg->data, 0, bytes + 1);
    msg->last = NULL;
    msg->next = NULL;
    msg->bytes = bytes;
    msg_count++;
    return msg;
  }
}

void TStringToken::update_msg(TToken* target, char *value, int len)
{
  if(target && value && len)
  {

      if(len == target->bytes)
      {
        memcpy(target->data, value, len);
      }
      else
      {
        char *newdata = (char *)malloc(strlen(value)+1);
        memset(newdata, 0, len+1);
        memcpy(newdata, value, len);
        free(target->data);
        target->data = newdata;
        target->bytes = len;
      }
  }
}

bool TStringToken::ChangeMsg(unsigned __int32 count, char *string)
{
  TToken *target = msg;
  for(unsigned __int32 i=0; i<count; i++)
    target = target->next;

  if(count < msg_count && string)
  {
    int len = strlen(string);
    int size_diff = len - target->bytes;
    int newsize = strlen(data) + size_diff;

    char *newdata = (char *)malloc(newsize+1);
    memset(newdata, 0, newsize+1);

    if(target->offset)
      memcpy(&newdata[0], &data[0], target->offset);
    memcpy(&newdata[target->offset], string, strlen(string));
    strcpy(&newdata[target->offset+strlen(string)],
           &data[target->offset+target->bytes]);
    free(data);
    data = newdata;

    //Analyze again
    clear_msg();
    analyze();
    return true;
  }
  return false;
}

unsigned __int32 TStringToken::GetMsgCount(void)
{
  return msg_count;
}

void TStringToken::clear_msg(void)
{
  if(msg_count)
  {
    TToken *delmsg = msg;
    TToken *nextdelmsg = msg->next;
    while(delmsg)
    {
      free(delmsg->data);
      free(delmsg);
      delmsg = nextdelmsg;
      if(delmsg)
        nextdelmsg = delmsg->next;
    }
  }
  msg = NULL;
  msg_count=0;
}

unsigned __int32 TStringToken::GetMsg(unsigned __int32 count, char *buff)
{
  if(count < msg_count)
  {
    TToken *target = msg;
    for(unsigned __int32 i=0; i<count; i++)
      target = target->next;

    if(buff)
      strcpy(buff, target->data);

    return target->bytes;
  }
  return 0;
}

unsigned __int32 TStringToken::GetData(char *buff)
{
  if(buff)
  {
    strcpy(buff, data);
  }
  return strlen(data);
}

void TStringToken::ChangeData(char *string)
{
  clear_msg();
  if(data)
    free(data);

  msg_count = 0;
  msg = NULL;
  //data = NULL;
  if(string){
      data = (char *)malloc(strlen(string) + 1);
      strcpy(data, string);
      analyze();
  }
}