99精品国产热久久91蜜凸,国产日韩综合,欧美午夜不卡视频

攑ֱ�阿狗 — Thu, 24 Mar 2016 07:29:00 GMT

摘要: 有问题的c++通信代码的识别，希望写c++的码农不要犯同样的错阅读全文

攑ֱ�阿狗 2016-03-24 15:29 发表评论

加快�~�译速度

攑ֱ�阿狗 — Tue, 26 Oct 2010 06:01:00 GMT

��目开发过�E�中最痛苦的就是头疼编译速度�Q�稍微做修改�~�译的时间比修改旉��更长
�pȝ��时髦，开发环境版本越高，机器配置再高(我的配置4G,I720),但vc的编译器速度一炚w��提高不了多少
提高�~�译速度��试了很多方�?
1.买更快的机器
2.更换�~�译器，vc6�q�是能保持最快的速度�Q�vs2008�{�等��来��垃�?br>3.更换操作�pȝ�� win2003
4.使用服务器编译，�?�Q?台机器协同进来编译工�E?

以上均不能让我有满意的效�?br>那最好的方式��是调整自己的代码结构了�Q�c�~�译器�ؓ何如老牛般吃力，��是�׃��c语言灉|��带来的问题，不同对象文�g兌��不正当将大大增大了编译时间�?br>所以在定义工程对象依赖关系�Ӟ��必须注意 �?br>我一般的做法是：
class A,class B, 那在 a.h 中先声明 class B,然后定义一个B*卛_��
只有在a.c内要用到B�l�构时才加上include "b.h"
�q�样代码兌��没有那么紧密了�Q�编译器也会变的聪明点了�Q�不会由于一个无关紧要的修改�Q�导致大扚w��的源文�g被重新编译�?br>

攑ֱ�阿狗 2010-10-26 14:01 发表评论

游戏IP代理

攑ֱ�阿狗 — Wed, 29 Sep 2010 17:17:00 GMT

摘要: v\:* {behavior:url(#default#VML);} o\:* {behavior:url(#default#VML);} w\:* {behavior:url(#default#VML);} .shape {behavior:url(#default#VML);} Normal 0 7.8 ��?0 2 false false fa... 阅读全文

攑ֱ�阿狗 2010-09-30 01:17 发表评论

游戏逆向逻辑接口定义

攑ֱ�阿狗 — Wed, 29 Sep 2010 16:40:00 GMT

摘要: 跟逆向的协同是制定标准交互接口gtr_api.h Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 /* 2 gtr_api.h 3 ========... 阅读全文

攑ֱ�阿狗 2010-09-30 00:40 发表评论

攑ֱ�阿狗 — Wed, 29 Sep 2010 16:38:00 GMT

  1 /*
  2
  3 2010.3.25 zhangbin
  4 1.create,定义game-core的网�l�接�?br>  5
  6 协定:
  7     1.数据�c�d��名称��N��d��T
  8
  9 2010.3.27 zhangin
10
11 2010.3.29 zhangbin
12 1. 取消工作单GameWorkSheetT�l�构
13 2. 修改 ISecureService.auth()安全认证的数据类�?br> 14 2010.3.30 zhangbin
15 1. heartbeat()�U�d��到IService接口
16 */
17
18
19 #ifndef _GTR_ICE
20 #define _GTR_ICE
21
22
23 module gtr {
24
25 dictionary<string,string>    HashValueSet;
26 dictionary<string,string>    ReturnValueT;
27 sequence<byte>                 ByteStreamT;
28 sequence<string>            StringListT;
29 sequence<HashValueSet>    HashValueListT;
30 sequence<int>                    IntListT;
31 sequence<StringListT>    StringListListT;
32
33 struct CallReturnT{
34     bool    succ;
35     string msg;
36     HashValueSet props;
37 };
38
39 const int IMAGEJPEG = 1;
40 const int IMAGEPNG =2 ;
41 const int IMAGEBMP = 3 ;
42
43
44 //囑փ�数据
45 struct ImageDataT{
46     int type;
47     ByteStreamT    bytes;
48     int width;
49     int height;
50 };
51
52 struct GameAuthDataT{
53     int             type;     // 1- 囄�� ,2 - 坐标
54     ImageDataT image; //�U�宝囄��
55     string seckey;      //�U�宝坐标
56 };
57
58
59 struct GameIdentifyT{
60     string id;            //游戏�~�号
61     string tradeNo;    //交易单号
62 };
63
64 struct ServiceIdentifyT{
65     string id;
66     string version;
67 };
68
69
70 interface IService{
71     int            getType();             //
72     ServiceIdentifyT    getId();                //service module id
73     int                             getTimestamp();        //获取�pȝ��旉��  1970之后�U�数
74     void                             shutdown();
75     void                             heartbeat(string senderType,string senderId);  //发送者类型和Id
76 };
77
78 /*
79 enum LogMsgLevelT{
80     logDEBUG,
81     logINFO,
82     logCRITICAL,
83     logERROR
84 };
85 */
86
87 struct LogMessageT{
88     int                     xclass;    //消息�c�d��
89     string                 msg;
90 };
91
92 //日志功能
93 interface ILogger {
94     void gameMsg(GameIdentifyT gameId,int timetick,LogMessageT msg);  // timetick - 1970~ s
95     void gameImage(GameIdentifyT gameId,int timetick,string opName,ImageDataT image);    //抓图 opName - 执行游戏步骤名称
96 };
97
98 //安全��理�Q�包括秘宝认证等
99 interface ISecure {
100     string auth(GameIdentifyT gameId,GameAuthDataT data);
101 };
102
103 //日志服务�?/span>
104 interface ILogServer extends ILogger,IService{
105
106 };
107
108 interface ISecureServer extends ISecure,IService{
109 };
110
111
112 //一个游戏�Q务相关的信息
113 enum GameWorkSheetTypeT{
114     gwsPost,                    //邮寄
115     gwsAccountAudit, //帐号审核
116     gwsVerify                //验证
117 };
118
119
120 //邮寄
121 struct GameWorkSheetPostT {
122     long money;
123 };
124 //审核
125 struct GameWorkSheetAccountAuditT {
126     string any;
127 };
128 //验证
129 struct GameWorkSheetVerifyT {
130     string any;
131 };
132
133 //交易��d��信息
134 //Tasklet包含所有的业务处理�c�d��Q�但同时只有一�U�有�?/span>
135 struct GameTaskletT{
136     string id;                            //��d��~�号
137     int      type;                            //处理�c�d��
138     string no;            //单号
139     string gameId;    //游戏�~�号
140     string account;    //帐号
141     string password;
142     string area;        //�?/span>
143     string server;    //服务�?/span>
144     string lineName;//�U��\名称(为空则lineNo)
145     short     lineNo;    //�U��\�~�号
146     string createTime;
147
148     GameWorkSheetPostT post;    //邮寄
149     GameWorkSheetAccountAuditT audit;
150     GameWorkSheetVerifyT        verify;
151 };
152
153 struct GameTaskResultT{
154     string id;        //��d��~�号
155     string no;        //单号 (冗余)
156     string gameId;    //游戏�~�号(冗余)
157     int result;        //处理�l�果
158     string errmsg;    //提示信息
159 };
160
161 //gtr控制服务端接�?/span>
162 interface IGameHost extends IService,ILogger,ISecure{
163     GameTaskletT                    getTask();        //获取��d��
164     void                                    completeTask(GameTaskResultT result);         //
165
166 };
167
168
169
170 };
171
172
173 #endif
174
175

攑ֱ�阿狗 2010-09-30 00:38 发表评论

攑ֱ�阿狗 — Mon, 10 May 2010 07:27:00 GMT

Ice的设计思想非常�?通过slice定义之后产生一堆的通信框架代码来自动化完成对象数据的序列化
�׃��ice是基于Rpc�?底层通信�l�节被屏蔽掉�?甚至是连接的自动重复建立,可喜又可�?有些应用必须要关心这些底部的通信�l�节,
如果直接用socket又嫌太麻烦了,不同的应用都是在重复的进行开发通信协议,解包和打包花销很很多的�_�֊�,�q�些工作都是重复�?没有技术含量而且�Ҏ��出错.
之前开发过mtslib通信库来解决socket通信问题,使两端都是以消息包的形式�q�行通信,解决了socket两段buffer的管�?br>也看�q�ice的代码实�?slice2cpp用yacc&lex�q�行词法语法的处�?br>对象的自动序列化�q�是我所感兴��的,同ice一��h��供一个通信环境,然后用户可以自定义自��q��通信数据,通过idl的�Ş式自动��生序列化代码�q�编译进用户工程.
�q�种方式与ice又不同在于没有那么傻瓜化,但简化了用户处理消息报的�q�程.
�q�样要完成一个类似ice的rpc调用也是没有那么��?br>yacc/lex,lemon,

攑ֱ�阿狗 2010-05-10 15:27 发表评论

完成swMap基本功能

攑ֱ�阿狗 — Thu, 20 Aug 2009 19:27:00 GMT

准备攑ּ�以前��目使用的地囑ּ�擎库和Gis代码到现在已�l�有�?个月�?br>现在swMap能做基本demo一丁点的功能了�Q�访问： www.sw2us.com/maps.php 或�?http://220.196.42.107/main.php
当初考虑到放弃之前的东西考虑的问题有很多�Q�当然有公司的知识��权问题，最主要的是之前的��品技术实在是设计的有点糟�p�。做开发的知道看别人的代码�q�且在这基础上去发扬光大�q�时间很头大和痛苦的事情�Q�特别是��到那些原本��是比较��闭和差劲的东西�?br>凭借自��q��的很多想法开始开发swMap��目�Q�以前的东西都抛弃没有做参考，从原始地囑֊�工设计、地图渲染服务器开发、然后就是基于Pc和Wince的客��L��开发，支持本地和远�E�加载地囄��方式�Q�重新设计的数据存储方式除了保留��单的�|�格存储和搜寻，已经把地图数据进行省份的分割�Q�而不像以前必��d��载单独的一个全国地图数据包�Q�地囄��g��设计成了多网格大��Ş式，以便支持同一个地图文件中��L��多的�~�放比和地图层�?br>开发��L��很辛苦，每天都是要做到夜�׃�h�?br>学习了很多东西，思考了很多东西�Q�反复的也有很多�Q�最�l�还是凭借自己比较宽的知识面�Q�运用了很多opensource的技术，旉��和效率当然是非常重要的，所以没有自己去重新实现一些基��的东西，比如matrix��是从cairo库中直接抄过来的�?br>在用c++开发地图服务器和客��L��时候也考虑了不同的通信方式和操作系�l�环境，��可能的可以支持更多的运行环境�?br>原本计划在昨晚wince版本之后马上支持symbian操作�pȝ��Q�但对symbian的开发研�I�了之后让我大失所望，其开发是非常低效的且通用性能太差�Q�后来网上得知nokia马上��抛弃symbian而怀抱linux了，�q��o我我马上考虑了移植linux的想�?br>很多��我提到静态网��地图方式，当然我不能做到像google�Q�openlayers�q�么强的客户端端�Q�也没精力去支持ogc那么的gis协议在地图服务器上，所以能演示基础的地囑֊�能开发了php的展�C�端�?br>flex和sliverlight都是非常好的技术，但对于ms一直没有好感，所以flex形成了我选择另一个展�C�客��L��的想法�?br>�|�上下了一堆的flex数据�Q�前后从接触actionscript到做好swFlex客户端一��p��?天时��_��发觉��来��喜�Ƣ这个东西了�Q�看来以后的前端开发要全换成flex�q�_��了�?br>目前做得swMap的功能非常有限，地图处理也是很简单，甚至�q�文本标注都没有��d��Q�只是提供了25个图�?6�U�别�~�放比在客户端展�C��?br>我想待我有时��_��我将�q�些都会完善��h��
原本很多带开发的技术也没有��d��Q�比如agg�Q�地�?叉树、RTree�Q�A*路由��法
朋友�l�我的几个Gps模块讑֤��q�几天要调通�ƈ攄��到地图上�?br>

攑ֱ�阿狗 2009-08-21 03:27 发表评论

auto_ptr/shared_ptr/week_ptr differences

攑ֱ�阿狗 — Sat, 12 Jul 2008 16:34:00 GMT

auto_ptr A,B A=B之后B指向内容��失�? auto_ptr属于scoped smart pointer

攑ֱ�阿狗 2008-07-13 00:34 发表评论

WINCE 讄��环境变量-�pȝ��加蝲路径

攑ֱ�阿狗 — Thu, 03 Jul 2008 17:24:00 GMT

{
        TCHAR pText[] = _T("\\Windows\\0\\NandFlashPartition\\MediaLib\0\\Storage Card\\MediaLib\0\0");
        CString strText(pText,sizeof(pText));
        SaveMultString(HKEY_LOCAL_MACHINE,_T("Loader"),_T("SystemPath"),strText,sizeof(pText));

        DeleteKey(HKEY_LOCAL_MACHINE,_T("SOFTWARE\\sample\\PLAY"));
    }

攑ֱ�阿狗 2008-07-04 01:24 发表评论

wxWidget的多语言

攑ֱ�阿狗 — Thu, 03 Jul 2008 17:19:00 GMT

摘要: wxlocale 初始化字�W�语�a��U�类 locale.Init(wxLANGUAGE_CHINESE );// locale.Init(wxLANGUAGE_FRENCH ); wxLocale::AddCatalogLookupPathPrefix(wx... 阅读全文

攑ֱ�阿狗 2008-07-04 01:19 发表评论

函数char2Hex()

攑ֱ�阿狗 — Sun, 22 Jun 2008 16:58:00 GMT

string Char2Hex(char a)
{
    string str = "";
    int n = a;
    for (int i=2*sizeof(char) - 1; i>=0; i--)
    {
        str += "0123456789ABCDEF"[((n >> i*4) & 0xF)];
    }
    return str;
}

攑ֱ�阿狗 2008-06-23 00:58 发表评论

攑ֱ�阿狗 — Mon, 12 May 2008 19:13:00 GMT

table 是个怪物�Q�有很多facets,�c�M��array,map,struct,整个是个混合物，用�v来也比较怪异�?br>t={1,2,3,a="gen",b=100}
t={[0]=1;["name"]="ultra"}
t.a, t.b , t[0] , t["name"]

表操作函�?
ipairs,pairs�q�代函数
table.getn(t)   len of table

================================================================
function() 可以接受��L��多的参数�Q�如果实参数�q�多��丢弃，�q�少��默认设�|��ؓnil
同样可以�q�回多个参数
a,b=foo()

表作为参��C��递到function
function rename( arg ) os.rename(arg.old,arg.new) end
rename{old="";new=""}

匿名函数(lambda in python )
foo = function(x) return x*2 end
局部函�?local f=function(x) ... end
================================================================
for n=start,end,step do ... end
while b do   ... end
repeat do .... until

if then .. elseif then ... end;

有意思的语法表达�?
    print a or b or c   如果a=false,��试b...

注释: --     --{ --}

字符串操�?    .. �q�接

==================================================
io 函数:
loadfile('test.lua')()    execute external lua script
loadstring('print 100')()

代码��试:
=======================
c�E�序调用lua函数
c �E�序:
void call_lua_func(){
    lua_State *s = lua_open();
    luaL_openlibs(s);
    int c = lua_gettop(s);
    luaL_dofile(s,"/nandflashpartition/test1.lua");
    lua_getglobal(s,"add");
    lua_pushnumber(s,0.25);
    lua_pushnumber(s,8);
    if( lua_pcall(s,2,1,0)){
        std::cout<< lua_tostring(s,-1)<    }
    double r;
    r = lua_tonumber(s,-1);
    lua_close(s);
}
lua�E�序:
function add(x,y)
    return x*y
end
--------------------------------
lua讉K��c�E�序�I�间变量

1.定义变量student.h
extern char * gender;
extern int class_count;

2.创徏pkg文�g student.pkg
$#include "student.h"
extern char * gender;
extern int class_count;

3.产生tolua++存根框架
tolua++ -o student.pkg

4.创徏lua��试代码 call_c.lua
print(gender)
print(class_count) 讉K��c �I�间的变�?br>
5.c��试代码
char * gender;
int class_count;
void lua_call_c(){
    int tolua_student_open (lua_State* tolua_S);
    lua_State * s = lua_open();
    luaopen_base(s);

    gender ="my gender is male!";
    class_count = 100;
    tolua_student_open(s);
    luaL_dofile(s,"/nandflashpartition/call_c.lua");
    lua_close(s);
}

6.build && test it!

攑ֱ�阿狗 2008-05-13 03:13 发表评论

�?C ��装串口数据协议�Q�可用于��式传输

攑ֱ�阿狗 — Fri, 23 Feb 2007 14:54:00 GMT

#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,�q�回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;nsize;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
#include
#include
#ifdef _UNIX
#include
#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:    计算含�{义字�W�串长度
*/
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    --    消息数据�?br />        s    --    起始内存地址
        e    --    �l�束地址 ,
*/
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:    分解指定内存到包�l�构
            成功分解出包立刻回送到应用接收�?( btsc_Context::notifier)
    param:
        s,e     内存地址 (处e)

** �~�冲��需�q�一步测�?包括�~�冲区大��调�? 不完整协议包格式的容�?br />*/
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�Q?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);
/*初始化上下文�Q?tx=发送处理函�?notifier=接收函数*/
struct btsc_Context c={tx:tx,notifier:notifier};

/*��试数据接收�q�解�?/
void rx(){
    char * msg=""
                 ""
                 ""; /*simulating data*/
    int len = strlen(msg);
    btsc_Parse(&c,msg,len);
}
/*发送处理过�E?/
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{
        /*构造消息包,�q�完成发�?/
        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

攑ֱ�阿狗 2007-02-23 22:54 发表评论

随便写个 �U�程�c?玩玩

攑ֱ�阿狗 — Fri, 23 Feb 2007 14:47:00 GMT

#ifndef _BT_THREAD_H
#define _BT_THREAD_H

#include

class btworkThread{
public:
   btworkThread( void(*entry)(btworkThread* ,void*),void* user){
       _entry = entry;
       _param = user;
       _thandle = CreateThread(NULL,NULL,(LPTHREAD_START_ROUTINE)btworkThread::run,user,NULL,&_tid);
   }
   void   stop(){
       _loop = false;
   }
   void   wait(){
       while(!_end){
           Sleep(20);
       }
       Sleep(20); // ensure that thread has terminated
   }
   void   stopAndWait(){
       stop();wait();
   }
   bool   loop(){
       return _loop;
   }
   void   code_begin(){
       _loop = true; _begin = true;_end=false;
   }
   void   code_end(){
       _loop = false; _begin = false;_end=true;
       CloseHandle(_thandle);
   }
protected:
   static void   run(btworkThread* thread){
       thread->_entry(thread,thread->_param);
   }
private:
   volatile bool   _loop,_begin,_end;
   void (*_entry)(btworkThread* ,void*);
   void*   _param;
   DWORD   _tid;
   HANDLE   _thandle;
};

攑ֱ�阿狗 2007-02-23 22:47 发表评论

闲来无事�Q�写个智能指针类玩玩

攑ֱ�阿狗 — Fri, 23 Feb 2007 14:39:00 GMT

    #include "btMutex.h"

template
class SmartHandlePtr{
    struct Handle{
        Handle(){
            ptr = NULL;
            cnt = 0;
        }
        void*    ptr;
        int        cnt;
        btLock    lock;
        void    inc(){
            btScopeLock sl(lock);
            cnt++;
        }
        void    dec(){
            btScopeLock sl(lock);
            cnt--;
        }
    };
public:
    SmartHandlePtr(const T* p){
        _ph = new Handle;
        _ph->ptr =(void*) p;
        _ph->inc();
    }

    ~SmartHandlePtr(){
        if( _ph ){
            _ph->dec();
            if( _ph->cnt==0){
                T* p;
                p = (T*)_ph->ptr;
                if( p ){
                    delete p;
                }
                delete _ph;
            }
        }
    }

    SmartHandlePtr(const SmartHandlePtr& shp){
        if( _ph ){
            _ph->dec();
            if( _ph->cnt==0){
                T* p;
                p = (T*)_ph->ptr;
                if( p){
                    delete p;
                }
                delete _ph;
            }
        }
        _ph = _ph;
        _ph->inc();
    }
    bool operator==(const T* p) {
        return _ph->ptr == p;
    }
    bool operator==(const SmartHandlePtr& shp){
        return _ph == shp._ph;
    }

    T* operator->(){
        return (T*)_ph->ptr;
    }

    T* get(){
        if( _ph && _ph->ptr){
            return (T*)_ph->ptr;
        }
        return NULL;
    }

private:
    Handle*    _ph;
};

攑ֱ�阿狗 2007-02-23 22:39 发表评论