#define OUT
#define INOUT
#define IN

#define INIT_LIST_HEAD(x)?? ?

#define btsc_TRUE ?? ?0
#define btsc_FALSE?? ?1
#define btsc_NULL ?? ?0

struct list_head{
?? ?struct list_head* prev,*next;
};


struct btsc_Property{
?? ?char * ?? ??? ?name;
?? ?char * ?? ??? ?value;?? ??? ?
};


struct btsc_Packet{
?? ?/*struct list_head?? ?list;*/
?? ?struct btsc_Property** ?? ?properties;
?? ?int?? ??? ??? ??? ?size;
?? ?int?? ??? ??? ??? ?capacity;
?? ?struct btsc_Context?? ?*?? ?ctx;
};

struct btsc_Packet* ?? ?btsc_Packet_Alloc(struct btsc_Context* );
void?? ??? ??? ??? ??? ?btsc_Packet_Free(struct btsc_Packet*);

struct btsc_Property*?? ?btsc_Property_Alloc(struct btsc_Context* ,char * name,char * value);
void?? ??? ??? ??? ??? ?btsc_Property_Free(struct btsc_Property*);


struct btsc_Property* ?? ?btsc_Property_Get(struct btsc_Packet* packet,char * name); ?? ?
void?? ??? ??? ??? ??? ?btsc_Property_Append(struct btsc_Packet* packet,struct btsc_Property * );


struct btsc_Context{
?? ?void (*tx)(struct btsc_Context*,unsigned char * data,int len);?? ??? ?
?? ?int (*notifier)(struct btsc_Packet* packet);/*外部釋放packet,返回NULL*/?? ??? ?
?? ?int?? ??? ?packet_cached_size;
?? ?int?? ??? ?recv_cached_capacity;?? ??? ??? ??? ??? ??? ?
?? ?char*?? ?recv_buff;?? ??? ??? ??? ??? ??? ??? ??? ??? ?
?? ?int?? ??? ?recv_size;?? ??? ?
?? ?void*?? ?user;?? ?// 外部數據傳遞?? ??? ??? ??? ??? ??? ??? ?
};


int ?? ?btsc_init(struct btsc_Context* IN ctx);?? ?
void ?? ?btsc_cleanup(struct btsc_Context* IN ctx);
int?? ??? ?btsc_Pack(struct btsc_Context* IN ctx,struct btsc_Packet* packet,unsigned char * INOUT buff,int* INOUT size);?? ?
void?? ?btsc_Parse(struct btsc_Context* , char * data,int len);


#define BTSC_PACKET_BEGIN(ctx) {\
?? ??? ??? ??? ??? ??? ??? ??? ?struct btsc_Context* _ctx_internel;\
?? ??? ??? ??? ??? ??? ??? ??? ?struct btsc_Packet * _pkt ;\
?? ??? ??? ??? ??? ??? ??? ??? ?_ctx_internel= (ctx);\
?? ??? ??? ??? ??? ??? ??? ??? ?_pkt = btsc_Packet_Alloc(_ctx_internel);
?? ??? ??? ??? ??? ??? ??? ??? ?
/* key is not suitable for vairable*/?? ??? ??? ??? ??? ??? ??? ??? ?
#define BTSC_NEW_PROPERTY(key,value)?? ?{\
?? ??? ??? ??? ??? ??? ??? ??? ??? ??? ??? ?struct btsc_Property * _ppt =btsc_Property_Alloc(_ctx_internel,key,value);\
?? ??? ??? ??? ??? ??? ??? ??? ??? ??? ??? ?btsc_Property_Append(_pkt,_ppt);\
?? ??? ??? ??? ??? ??? ??? ??? ??? ??? ?}
#define BTSC_PACKET_END()?? ??? ?btsc_Pack(_ctx_internel,_pkt,btsc_NULL,0);\
?? ??? ??? ??? ??? ??? ??? ??? ?btsc_Packet_Free(_pkt);\
?? ??? ??? ??? ??? ??? ??? ??? ?}

#define BTSC_FOREACH(packet,ppt)?? ?{\
?? ??? ??? ??? ??? ??? ??? ??? ??? ?int n;\
?? ??? ??? ??? ??? ??? ??? ??? ??? ?for(n=0;n<packet->size;n++){\
?? ??? ??? ??? ??? ??? ??? ??? ??? ??? ?ppt = packet->properties[n];
#define BTSC_END_FOREACH()?? ??? ??? ?}\
?? ??? ??? ??? ??? ??? ??? ??? ?}








/*
??? name:??? ??? ??? btsc
??? ??? ??? ??? ??? serial communicating? with bluetooth and app-user
??? desc:??? ??? ??? pair parameter codec
???
??? ??? packet=[ key:name,...]
??? ???
??? implemented: ??? zhangbin ,? 3 hours occupied
??? date:??? ??? ??? 2007-01-26
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _UNIX
#include <unistd.h>
#endif
#include "btsc.h"

#define PACKET_HEAD??? ??? '<'
#define PACKET_TAIL??? ??? '>'
#define PROPERTY_DELIMITER??? ','
#define PAIR_DELIMITER??? ??? '='
#define ESCAPE_CHAR??? ??? ??? '\\'


int calcEscapleLength(char * str);
char* escape_copy(char * dest,char * src);
void trim_escape_copy(char * dest,char * src,int size);
int? calcPacketLength(struct btsc_Packet* pkt);
int??? is_escape_char(char c);
void parseProperty(struct btsc_Packet * pkt,char * s,char * e);
void parsePacket(struct btsc_Context* ctx,char * s,char* e);
char* ??? __memchr(char * s,char* e,char c);

char escape_ch_table[]={PACKET_HEAD,PACKET_TAIL,PROPERTY_DELIMITER,PAIR_DELIMITER,ESCAPE_CHAR,'\0'};

struct btsc_Packet* ??? btsc_Packet_Alloc(struct btsc_Context* ctx){???
??? struct btsc_Packet * pt = malloc(sizeof(struct btsc_Packet));??? ???
??? pt->size = 0;
??? pt->capacity = ctx->packet_cached_size;
??? pt->properties=malloc(pt->capacity*sizeof(struct btsc_Property*));???
??? pt->ctx = ctx;
??? return pt;???
}

void??? btsc_Packet_Free(struct btsc_Packet* pt){???
??? struct btsc_Property** tmp;
??? if( !pt ) ??? return ;
??? tmp = pt->properties;
??? while(pt->size--){
??? ??? btsc_Property_Free(*tmp++);??? ??? ??? ???
??? }??? ???
??? if( pt->properties){
??? ??? free(pt->properties);?
??? }
??? free(pt);
}


struct btsc_Property*??? btsc_Property_Alloc(struct btsc_Context* ctx,char * name,char * value){
??? struct btsc_Property * ppt;
??? printf("enter btsc_Property_Alloc()\n");
??? ppt = malloc( sizeof( struct btsc_Property) );
??? if(!ppt)??? printf("error: malloc failed (s1)\n");
??? ppt->name = malloc( strlen(name)+1);
??? if( !ppt->name ) printf("error: malloc failed (s2)\n");
??? strcpy(ppt->name,name);???
??? ppt->value = malloc( strlen(value)+1);
??? if( !ppt->value) printf("error: malloc failed (s3),str:%s, len: %d\n",value,strlen(value)+1);
??? strcpy( ppt->value,value);
??? return ppt;
}

void??? ??? btsc_Property_Free(struct btsc_Property* ppt){
??? if( !ppt )??? return;
??? free( ppt->name);
??? free( ppt->value);
??? free( ppt);
}

/* scan pointer array */
struct btsc_Property* ??? btsc_Property_Get(struct btsc_Packet* pkt,char * name){
??? int size;
??? struct btsc_Property* ppt;
??? size = pkt->size;
??? while(size--){
??? ??? ppt = pkt->properties[size];
??? ??? if( !strcmp( name, ppt->name ) ){
??? ??? ??? return ppt;/*that's ok */
??? ??? }
??? }
??? return btsc_NULL;
}

/* low effeciency, memory allocation,more costs*/
void??? btsc_Property_Append(struct btsc_Packet* pt,struct btsc_Property * ppt){
??? struct btsc_Property** tmpppt;
??? if( pt->size==pt->capacity){ ??? ???
??? ??? pt->capacity += pt->ctx->packet_cached_size;???
??? ??? tmpppt = pt->properties;??? ???
??? ??? pt->properties = malloc( pt->capacity * sizeof( struct btsc_Property**) );
??? ??? memcpy( pt->properties, tmpppt, pt->size * sizeof( struct btsc_Property**));
??? ??? free( tmpppt);
??? }
??? pt->properties[pt->size++]=ppt;???
}

int ??? btsc_init(struct btsc_Context* ctx){???
??? ctx->packet_cached_size = 10;???
??? if( ctx->recv_cached_capacity==0){
??? ??? ctx->recv_cached_capacity = 1024*2;???
??? }
??? ctx->recv_buff = malloc( ctx->recv_cached_capacity );
??? ctx->recv_size = 0;
??? return btsc_TRUE;
}

void ??? btsc_cleanup(struct btsc_Context* ctx){
??? free(ctx->recv_buff);???
}

/*
**??? name:??? calcEscapleLength
**??? desc:??? 計算含轉義字符串長度
*/
int ??? calcEscapleLength(char * str){
??? int len;
??? char * pesc;
??? len = 0;???
??? while( *str ){
??? ??? pesc = escape_ch_table;
??? ??? while( *pesc ){
??? ??? ??? if( *pesc==*str){
??? ??? ??? ??? len++;
??? ??? ??? ??? break;
??? ??? ??? }
??? ??? ??? pesc++;
??? ??? }??? ???
??? ??? str++;
??? }???
??? return len;
}


char* escape_copy(char * dest,char * src){
??? char * pesc;
??? while( *src ){
??? ??? pesc = escape_ch_table;
??? ??? while( *pesc ){
??? ??? ??? if( *pesc==*src){
??? ??? ??? ??? *dest++=ESCAPE_CHAR;
??? ??? ??? ??? break;
??? ??? ??? }
??? ??? ??? pesc++;
??? ??? }
??? ??? *dest++=*src++;??? ??? ??? ???
??? }???
??? return dest;???
}

void trim_escape_copy(char * dest,char * src,int size){
??? int last_escape = btsc_FALSE;
??? while( size--){
??? ??? if( *src == ESCAPE_CHAR && last_escape != btsc_TRUE){??? ???
??? ??? ??? last_escape = btsc_TRUE??? ;
??? ??? ??? src++;
??? ??? ??? continue;
??? ??? }
??? ??? last_escape = btsc_FALSE;
??? ??? *dest++=*src++;??? ???
??? }
}

int?? ??? calcPacketLength(struct btsc_Packet* pkt){
??? int len;
??? int size;
??? struct btsc_Property* ppt;???
??? len = 0;
??? size = pkt->size;
??? while( size--){
??? ??? ppt = pkt->properties[size];???
??? ??? len+=strlen(ppt->name)+strlen(ppt->value);???

??? ??? len+= calcEscapleLength(ppt->name);
??? ??? len+= calcEscapleLength(ppt->value);???
??? }
??? len+= pkt->size*2+1;
??? return? len;
}


int??? ??? btsc_Pack(struct btsc_Context*? ctx,struct btsc_Packet* pkt,unsigned char * obuff,int* osize){
??? struct btsc_Property* ppt;
??? int size;
??? int len;
??? unsigned char * buff;
??? char * pbuff;
??? len = calcPacketLength( pkt);
??? buff = malloc( len );
??? size = pkt->size;
??? pbuff = (char*)buff;
??? *pbuff++=PACKET_HEAD;???
??? while( size--){
??? ??? ppt = pkt->properties[size];???
??? ??? pbuff = escape_copy(pbuff,ppt->name);
??? ??? *pbuff++=PAIR_DELIMITER;
??? ??? pbuff = escape_copy(pbuff,ppt->value);
??? ??? if( size ){
??? ??? ??? *pbuff++=PROPERTY_DELIMITER;??? ??? ???
??? ??? }
??? }
??? *pbuff = PACKET_TAIL;
??? if( ctx->tx ){
??? ??? ctx->tx(ctx,buff,len);
??? }
??? if( obuff && *osize >=len){
??? ??? memcpy( obuff, buff ,len);
??? ??? *osize = len;
??? }

??? free(buff);
??? return btsc_TRUE;???
}

/* e not in range*/
char* ??? __memchr(char * s,char* e,char c){
??? while( s!=e){
??? ??? if( *s == c){
??? ??? ??? return s;
??? ??? }??? ???
??? ??? s++;
??? }
??? return btsc_NULL;
}

int??? ??? is_escape_char(char c){
??? return btsc_FALSE;???
}

/*
??? name: parseProperty
??? desc: 指定內存范圍中提取屬性? key=>value
??? ??? 搜索包含e
??? params:???
??? ??? pkt??? --??? 消息數據包
??? ??? s??? --??? 起始內存地址
??? ??? e??? --??? 結束地址 ,
*/
void parseProperty(struct btsc_Packet * pkt,char * s,char * e){
??? char * p1,*p2;
??? int n;
??? struct btsc_Property*??? ppt;
??? p1 = s ;
??? p2 = e;
__REPEAT:???
??? p1 = __memchr(p1,e+1,PAIR_DELIMITER);
??? if( p1 ){
??? ??? if( *(p1-1) == ESCAPE_CHAR ){
??? ??? ??? p1++;
??? ??? ??? goto __REPEAT;
??? ??? }
??? ??? ppt = malloc( sizeof( struct btsc_Property ));
??? ??? n = p1-s; ??? ???
??? ??? ppt->name = malloc( n+1 );
??? ??? memset(ppt->name,0,n+1);??? ???
??? ??? trim_escape_copy(ppt->name,s,n);
??? ???
??? ??? n =e-p1;
??? ??? ppt->value = malloc( n+1);
??? ??? memset(ppt->value,0,n+1);
??? ??? trim_escape_copy(ppt->value,p1+1,n);
??? ???
??? ??? btsc_Property_Append(pkt,ppt);
??? }
}

/*
??? name: parsePacket
??? desc:??? 分解指定內存到包結構
??? ??? ??? 成功分解出包立刻回送到應用接收者 ( btsc_Context::notifier)
??? param:
??? ??? s,e ??? 內存地址 (處e)

** 緩沖區還需進一步測試,包括緩沖區大小調節, 不完整協議包格式的容錯
*/
void ??? parsePacket(struct btsc_Context* ctx,char * s,char* e){
??? char *p,*p1,*p2;
??? struct btsc_Packet * pkt;
??? if( e-s <=1 ){
??? ??? return ;
??? }
??? pkt = btsc_Packet_Alloc(ctx);
???
??? p1 = s+1;
??? p2 = e-1;
??? p = p1;
__REPEAT:???
??? p = __memchr(p,e,PROPERTY_DELIMITER);
??? if( p ){
??? ??? if( *(p-1)==ESCAPE_CHAR){
??? ??? ??? p = p+1;
??? ??? ??? goto __REPEAT;
??? ??? }
??? ??? parseProperty(pkt,p1,p-1);
??? ??? p1 = ++p;
??? ??? goto __REPEAT;
??? }
??? /*allow one property reside in*/
??? parseProperty(pkt,p1,e-1);
??? if( ctx->notifier ){
??????? if(ctx->notifier(pkt)){ /* nonzero value， delete internal*/
??????????? btsc_Packet_Free(pkt);??? ???????
??????? }
??? }else{
??? ?? btsc_Packet_Free(pkt);???
??? }
}

void??? btsc_Parse(struct btsc_Context* ctx, char * data,int size){
??? int len ;
_RESTART:
??? while( size ){
??? ??? len = ctx->recv_cached_capacity - ctx->recv_size;
??? ??? if( len >0){
??? ??? ??? if( size <= len){
??? ??? ??? ??? len = size;
??? ??? ??? ??? size = 0;
??? ??? ??? }else{
??? ??? ??? ??? size-=len;
??? ??? ??? }
??? ??? ??? memcpy( ctx->recv_buff+ctx->recv_size,data,len);
??? ??? ??? ctx->recv_size+=len;
??? ??? ??? data+=len;
??? ??? }???
??? ???
??? ??? {
??? ??? ??? char * p1,*p2;??? ??? ???
_RESCAN:??? ??? ???
??? ??? ??? p1 = ctx->recv_buff;
_RESCAN_HEAD:??? ??? ??? ?
??? ??? ??? p1 = __memchr(p1,ctx->recv_buff+ctx->recv_size,PACKET_HEAD);??? ??? ???
??? ??? ??? if( !p1 ){
??? ??? ??? ??? ctx->recv_size =0;
??? ??? ??? ??? if( size ){
??? ??? ??? ??? ??? goto _RESTART;
??? ??? ??? ??? }
??? ??? ??? }
??? ??? ??? if( p1>ctx->recv_buff && *(p1-1)==ESCAPE_CHAR){ /* "\<" */
??? ??? ??? ??? p1++;
??? ??? ??? ??? goto _RESCAN_HEAD;???
??? ??? ??? }
??? ??? ???
??? ??? ??? /*move backward*/
??? ??? ??? ctx->recv_size -=(p1-ctx->recv_buff);
??? ??? ??? memmove(ctx->recv_buff,p1, ctx->recv_size);
??? ??? ??? p1=ctx->recv_buff;
??? ??? ??? p2 = p1+1;
_RESCAN_TAIL:??? ??? ???
??? ??? ??? p2 = __memchr(p2,ctx->recv_buff+ctx->recv_size,PACKET_TAIL);
??? ??? ??? if( !p2 ){
??? ??? ??? ??? if( ctx->recv_size == ctx->recv_cached_capacity ){
??? ??? ??? ??? ??? ctx->recv_size? = 0;
??? ??? ??? ??? }
??? ??? ??? ??? goto _RESTART;
??? ??? ??? }
??? ??? ??? if( *(p2-1) == ESCAPE_CHAR ){
??? ??? ??? ??? p2++;
??? ??? ??? ??? goto _RESCAN_TAIL;???
??? ??? ??? }
??? ??? ???
??? ??? ??? parsePacket(ctx,p1,p2);
??? ??? ??? ctx->recv_size -=p2-p1+1;
??? ??? ??? if( ctx->recv_size ){
??? ??? ??? ??? memmove(ctx->recv_buff,p2+1,ctx->recv_size);
??? ??? ??? ??? goto _RESCAN;
??? ??? ??? }??? ??? ??? ?
??? ??? }??? ???
??? }
}

/*?? debug */
#ifdef _DEBUGX
void tx(unsigned char * data,int len);
void notifier(struct btsc_Packet* packet);
/*初始化上下文， tx=發送處理函數,notifier=接收函數*/
struct btsc_Context c={tx:tx,notifier:notifier};

/*測試數據接收并解析*/
void rx(){???
??? ?char * msg="<MSG=HELLO,NAME=SCOTT>"
??? ???? ??? ??? "<MSG2=HELLO2,NAME2=SCOTT2>"
??? ???? ??? ??? "<MSG3=HELLO3,NAME3=SCOTT3>"; /*simulating data*/
??? int len = strlen(msg);
??? btsc_Parse(&c,msg,len);
}
/*發送處理過程*/
void tx(unsigned char * buff,int len){???
??? char *outmsg = malloc(1024*10);
??? memset(outmsg,0,1024*10);
??? memcpy(outmsg,buff,len);
??? printf("encode str: %s\n",outmsg);
??? free(outmsg);
??? btsc_Parse(&c,buff,len);
}

void notifier(struct btsc_Packet* packet){
??? struct btsc_Property * ppt;
??? ppt = btsc_Property_Get(packet,"MSG");
??? if(ppt)
??? ??? printf("property get: MSG=>%s\n",ppt->value);
??? /*遍歷包內屬性參數*/
??? BTSC_FOREACH(packet,ppt);
??? printf("packet: %s=>%s\n",ppt->name,ppt->value);
??? BTSC_END_FOREACH();
}

int main(){
??? int r;
??? /*optional*/
??? c.recv_cached_capacity = 1024; /*初始化接收緩沖區大小 byte*/
??? c.packet_cached_size = 5;??? /*消息包緩沖屬性個數*/
??? btsc_init(&c);??? ??? ??? /*上下文初始化*/
??? puts("test rx()...");
??? rx();??? /*接*/
??? puts("escape testing...");???
??? do{
??? ??? /*構造消息包,并完成發送*/
??? ??? BTSC_PACKET_BEGIN(&c);
??? ??? BTSC_NEW_PROPERTY("MSG","calling");

??? ??? BTSC_PACKET_END();???
??? ??? usleep(1000*50);
??? ??? printf(">>seq:%d\n",r);
??? }while(0);
??? ???
??? btsc_cleanup(&c);???
???
??? return 0;
}


#endif