sproto 数据格式图解

sproto 也是 云风 写的一个开源的 数据描述语言 库，可以将数据进行序列化和反序列化 主要用于数据存储、通信协议订制等方面。和 Google公司开发 protobuf 类似

至于为什么重造轮子，是因为 protobuf 作为国际大公司的产品，当然不是想着如何在精简而是想着如何扩大影响力。也就是普适性。那么带来的问题就是会有一些东西是咱们做游戏开发用不到的。但是你又不得不为使用它而买单。而 云风 一开始也是用的 protobuf 后面他也认为是时候做下减法了。于是乎 sproto 就被造出来了。
它长这样的：

#定义数据结构：
person { name = "Alice" ,  age = 13, marital = false } 

03 00 (fn = 3)
00 00 (id = 0, value in data part)
1C 00 (id = 1, value = 13)
02 00 (id = 2, value = false)
05 00 00 00 (sizeof "Alice")
41 6C 69 63 65 ("Alice")

相对于 protobuf ， sproto 更精简，编解码更快。那么做到这些东西并不是说 云风 比Google公司厉害，而是 sproto 去掉了一些游戏开发中不需要，或者不常用的特性。更适合游戏开发使用。准确来说更适合使用 lua 进行开发的游戏使用。因为 云风 还为 lua 做了一层 RPC 协议封装。其他语言的话就需要自己撸了，之前我就撸了一个 js 版本的sproto，现在公司还在用。效果还行。

那么上面定义的数据怎么被序列化成二进制数据的，为了解释清楚这个问题照惯例我要上图了

sproto.jpg

原文
所有的数字编码都是以小端方式(little-endian) 编码。
打包的单位是一个结构体（用户定义的类型） 每个包分两个部分：1\. 字段 2\. 数据块

首先是一个 word n，描述字段的个数，接下来有 n 个 word 描述字段的内容。这个结构体的前半部分的长度就是 (n+1) * 2 字节。

字段的 tag 从 0 开始累加，每处理一个字段，将 tag 加一。

如果一个字段 v 为奇数，则把当前 tag 加上 (v-1)/2 + 1 ，并继续处理下一个字段值。 如果一个字段为 0 ，表示这个字段引用后面的一个数据块。 如果一个字段不为 0(且为偶数），这个字段的值为 v/2 - 1。（可以表示 [0, 32767] 的值）

接下来是被上面字段引用的数据块。

数据块用于描述字段中的大数据。它是由一个 dword 长度 + 字节串构成。通常用来表示数组或结构。大于 32767 的整数和负整数用 4 字节或 8 字节长的数据块表示(取决于需要和实现)。

数组的编码就是把同一类型的数据依次打包成数据块。如果是布尔数组，按 1 字节一个编码。如果是整数数组，它比较特殊，会根据需要打包成 4 字节或 8 字节一个数字；第一字节是 4 或 8 ，指明后面的整数宽度。

最后，数据中的 0 将被压缩的。压缩算法见[上一篇 blog](http://blog.codingnow.com/2014/07/ejoyproto.html) 。

这就是数据编码后的样子，细心的同学不难看出数据段中，描述长度的类型都是32位，可能有些人会问都用32位来描述长度是不是太浪费了。

别担心，以云大这种追求极简的人不可能做出这样的事情。下面是打包的流程

pack.jpg

看清楚了没有，没用到的字节其实是被压缩了的。

下面也贴一下产生上面数据的代码。注意，sproto.c 并没有给上面的数据分配内存，而是由调用层去分配，并且 sproto.c 只是 做了数据长度的写入。数据内容

都是 调用层去做的 默认是 lsproto.c 给 lua 用的，当然你也可以自己写你喜欢的。

代码很多，但是你看下面的编码函数就够了，解码就是反向操作。

sproto.c

int
sproto_encode(const struct sproto_type *st, void * buffer, int size, sproto_callback cb, void *ud) {
   //回调时候回传到上层的结构体
   struct sproto_arg args;
   //头部段指针
   uint8_t * header = buffer;
   //当前数据写入的位置
   uint8_t * data;
   //头部段总长度
   int header_sz = SIZEOF_HEADER + st->maxn * SIZEOF_FIELD;
   int i;
   //当前写到第几个字段
   int index;
   //上次的tag
   int lasttag;
   int datasz;
   if (size < header_sz)
       return -1;
   args.ud = ud;
   //先把 buffer 分成 header部分（2个字节） | header_sz（st->maxn * SIZEOF_FIELD） | data（数据段--可扩展的）
   data = header + header_sz;
   size -= header_sz;
   //有数据字段的数量索引
   index = 0;
   lasttag = -1;
   for (i=0;in;i++) {
       struct field *f = &st->f[i];
       int type = f->type;
       //只有字段类型为整形并且小于0xEFFF才有改变
       //如果=0则这个字段的值被打包到数据段
       int value = 0;
       //这字段写入数据的长度
       int sz = -1;
       args.tagname = f->name;
       args.tagid = f->tag;
       args.subtype = f->st;
       args.mainindex = f->key;
       args.extra = f->extra;
       if (type & SPROTO_TARRAY) {
           args.type = type & ~SPROTO_TARRAY;
           sz = encode_array(cb, &args, data, size);
           //数组先写入4个字节表示长度
           //后面的解析和下面的类似，复杂数据前面加4个字节长度
           //sz 就是已经写了多少字节
       } else {
           args.type = type;
           args.index = 0;
           switch(type) {
           case SPROTO_TINTEGER:
           case SPROTO_TBOOLEAN: {
               union {
                   uint64_t u64;
                   uint32_t u32;
               } u;
               args.value = &u;
               args.length = sizeof(u);
               sz = cb(&args);
               if (sz < 0) {
                   if (sz == SPROTO_CB_NIL)
                       continue;
                   if (sz == SPROTO_CB_NOARRAY)    // no array, don't encode it
                       return 0;
                   return -1;  // sz == SPROTO_CB_ERROR
               }
               if (sz == SIZEOF_INT32) {
                   if (u.u32 < 0x7fff) {
                       value = (u.u32+1) * 2;
                       sz = 2; // sz can be any number > 0
                   } else {
                       sz = encode_integer(u.u32, data, size);
                   }
               } else if (sz == SIZEOF_INT64) {
                   sz= encode_uint64(u.u64, data, size);
               } else {
                   return -1;
               }
               break;
           }
           case SPROTO_TSTRUCT:
           case SPROTO_TSTRING:
               //写入长度后还是递归调用到这边
               sz = encode_object(cb, &args, data, size);
               //data 前4个字节放总长度，后面的放到 args->value
               //上层逻辑按各自的数据结构写入到 args->value
               //sz 是这次一共用了多少个字节
               break;
           }
       }
      
       if (sz < 0)
           return -1;
       if (sz > 0) {
           //record 如果为 0 则表示数据放在了 数据段
           //record 如果为 基数 则表示跳过若干个字段
           //record 如果为 偶素 则表示数据为小整形
           uint8_t * record;
           //tag 的意义就是打包的数据中有部分字段可能没有数据
           //需要记录跳过几个字段。并且把跳过的信息也记录在描述字段中，用基数值来表示
           //描述字段偶数值就是小整形和bool
           //描述字段值为0就是把数据放在了数据段上
           
           int tag;
           if (value == 0) {
               data += sz;
               size -= sz;
           }
           record = header+SIZEOF_HEADER+SIZEOF_FIELD*index;
           tag = f->tag - lasttag - 1;
           
           //两个不连续的字段中,需要额外加2个字节的跳过信息
           if (tag > 0) {
               // skip tag
               tag = (tag - 1) * 2 + 1;
               //这里返回 -1 重新分配 buffer 内存，大于 ENCODE_MAXSIZE 会报错和结束
               if (tag > 0xffff)
                   return -1;
               record[0] = tag & 0xff;
               record[1] = (tag >> 8) & 0xff;
               ++index;
               record += SIZEOF_FIELD;
           }
           //如果有写入数据
           ++index;
           // value 为 0 数据在数据段
           record[0] = value & 0xff;
           record[1] = (value >> 8) & 0xff;
           //为了计算空字段 记录上一个 tag 等于 当前 tag
           lasttag = f->tag;
       }
   }
   //如果全部的字段都没有数据这里就是 0x00 0x00
   header[0] = index & 0xff;
   header[1] = (index >> 8) & 0xff;
   //计算用掉的数据部分长度
   datasz = data - (header + header_sz);
   data = header + header_sz;
   //如果有空的字段就收缩
   if (index != st->maxn) {
       //header部分（2个字节） | 收缩这部分 header_sz（st->maxn * SIZEOF_FIELD）| data
       memmove(header + SIZEOF_HEADER + index * SIZEOF_FIELD, data, datasz);
   }
   //返回写入数据的总长度
   return SIZEOF_HEADER + index * SIZEOF_FIELD + datasz;
}

下次再写一篇 sproto rpc 方面的文章。