juggle语法规范如下：
类型:
bool -> in cpp bool int -> in cpp int64 float -> in cpp double string -> in cpp std::string array -> in cpp std::vector struct -> in cpp object
函数的定义则同c语言：void rpctest1(int argv1, bool argv2, string argv3, float argv4, array<int> argv5);
整体的juggle语法如下:
module juggle{
void rpctest1(int argv1, bool argv2, string argv3, float argv4, array<int> argv5);
void rpctest2(int argv1, bool argv2, string argv3, float argv4, array<int> argv5);
}
其中module对应c++中的class，并且在服务器端会被codegen实现为一个单件，无需用户定义句柄有codegen生成对应的create代码。
codegen会依据module中函数定义，生成如下代码:
#include <juggle.h>
class juggle: public module{
public:
juggle() : module(ch, juggleuuid::UUID()){
_service_handle->register_module_method(juggle_rpctest1,boost::bind(&juggle::call_rpctest1, this, _1));
_service_handle->register_module_method(juggle_rpctest2,boost::bind(&juggle::call_rpctest2, this, _1));
}
~juggle(){
}
virtual void rpctest1(int64_t argv1,bool argv2,std::string argv3,double argv4,std::vector<int64_t> argv5) = 0;
void call_rpctest1(boost::shared_ptr<channel> ch, boost::shared_ptr<object> v){
auto argv1 = (*v)["argv1"].asint();
auto argv2 = (*v)["argv2"].asbool();
auto argv3 = (*v)["argv3"].asstring();
auto argv4 = (*v)["argv4"].asfloat();
std::vector<int64_t> argv5;
for(int i = 0; i < (*v)["argv5"].size(); i++){
v.push_back((*v)["argv5"][i].asint());
}
auto ret = rpctest1(argv1, argv2, argv3, argv4, argv5);
boost::shared_ptr<object> r = boost::make_shared<object>();
(*r)["suuid"] = (*v)["suuid"];
(*r)["method"] = (*value)["method"];
(*r)["ret"] = ret;
ch->push(r);
}
virtual void rpctest2(int64_t argv1,bool argv2,std::string argv3,double argv4,std::vector<int64_t> argv5) = 0;
void call_rpctest2(boost::shared_ptr<channel> ch, boost::shared_ptr<object> v){
auto argv1 = (*v)["argv1"].asint();
auto argv2 = (*v)["argv2"].asbool();
auto argv3 = (*v)["argv3"].asstring();
auto argv4 = (*v)["argv4"].asfloat();
std::vector<int64_t> argv5;
for(int i = 0; i < (*v)["argv5"].size(); i++){
v.push_back((*v)["argv5"][i].asint());
}
auto ret = rpctest2(argv1, argv2, argv3, argv4, argv5);
boost::shared_ptr<object> r = boost::make_shared<object>();
(*r)["suuid"] = (*v)["suuid"];
(*r)["method"] = (*value)["method"];
(*r)["ret"] = ret;
ch->push(r); }
};
可以看到，codegen实现了网络层面的消息响应、协议pack/unpack以及对rpc函数的调用，返回值封包发送的代码。用户只需要继承module并实现对应的rpc函数。
其中对于obejct的定义见 https://github.com/NetEase/fossilizid/blob/master/juggle/interface/object.h
我定义了一个纯虚类，用于规范一个通信协议参数入栈和访问的接口
然后定义了一个channel https://github.com/NetEase/fossilizid/blob/master/juggle/interface/channel.h
用于规范通信的接口
对于通信而言,push/pop是非常上层的一个接口，但是这样的设计目的在于提供一个宽泛的抽象，这里通信的可以是一个消息队列，一个基于共享内存的本地跨进程通信，同样也可以是socket。
btw:另一个原因是我自己封装的网络库的长相是这样的 https://github.com/NetEase/fossilizid/tree/master/remoteq, remotoq提供的通信句柄正是channel，而提供的访问接口则是push/pop。并且通过模板参数配置了网络协议的pack/unpack。我这么实现是为了方便代码复用。
然后是对dsl语言的编译：
juggle的语法定义的关键字，除了变量类型，就只有module和struct。对于一个module的定义，在module之后是是这个module的命名，之后是'{'表示此module定义开始，至'}'表示此module定义结束。module的分析代码如下:
class module(object):
def __init__(self):
self.keyworld = ''
self.name = ''
self.module = []
self.machine = None
def push(self, ch):
if ch == '}':
self.machine = None
return True
if self.machine is not None:
if self.machine.push(ch):
self.module.append(self.machine.func)
self.machine.clear()
else:
if ch == '{':
self.name = deleteNoneSpacelstrip(self.keyworld)
self.keyworld = ''
self.machine = func()
return False
self.keyworld += ch
return False
在检索到'{'之后开始对module定义的分析，至'}'结束这个module的定义。
因为dsl语言本身的特性，module中只有函数定义，struct中变量定义。所以在module中，只需要分析函数定义。
self.machine = func()，对函数分析器的定义如下:
class func(object):
def __init__(self):
self.keyworld = ''
self.func = []
self.argvtuple = None
def clear(self):
self.keyworld = ''
self.func = []
self.argvtuple = None
def push(self, ch):
if ch == ' ' or ch == '\0':
self.keyworld = deleteNoneSpacelstrip(self.keyworld)
if self.keyworld != '':
if self.argvtuple is None:
self.func.append(self.keyworld)
else:
self.argvtuple.append(self.keyworld)
self.keyworld = ''
return False
if ch == ',':
if self.keyworld != '':
self.argvtuple.append(deleteNoneSpacelstrip(self.keyworld))
self.func.append(self.argvtuple)
self.keyworld = ''
self.argvtuple = []
return False
if ch == '(':
self.func.append(deleteNoneSpacelstrip(self.keyworld))
self.argvtuple = []
self.keyworld = ''
return False
if ch == ')':
if self.keyworld != '':
self.argvtuple.append(deleteNoneSpacelstrip(self.keyworld))
self.func.append(self.argvtuple)
self.keyworld = ''
return False
if ch == ';':
return True
self.keyworld += ch
return False
因为无需考虑其他的语法要素的区分，函数定义的分析只需要考虑依次提取返回值类型，函数名，(,参数定义，),;函数定义结束。符号表示如下:
rettype funcname(argvlist...);
之后是对struct的分析,与module类似，在struct之后的既是struct name的定义，之后是'{'开始struct的定义，之'}'结束此struct的定义，代码如下:
class struct(object):
def __init__(self):
self.keyworld = ''
self.name = ''
self.struct = []
self.argvdef = []
def push(self, ch):
if ch == ' ' or ch == '\0':
if self.keyworld != '':
self.argvdef.append(self.keyworld)
if ch == '{':
self.name = deleteNoneSpacelstrip(self.keyworld)
self.keyworld = ''
return False
if ch == ';':
self.struct.append(self.argvdef)
self.argvdef = []
if ch == '}':
return True
self.keyworld += ch
return False
对于struct中的变量定义，同样以'type name;'的方式直接分割。
之后是对jeggle文件的整体分析:
class statemachine(object):
Moduledefine = 0
Funcdefine = 1
def __init__(self):
self.keyworld = ''
self.module = {}
self.struct = {}
self.machine = None
def push(self, ch):
if self.machine is not None:
if self.machine.push(ch):
if isinstance(self.machine, module):
self.module[self.machine.name] = self.machine.module
self.machine = None
if isinstance(self.machine, struct):
self.struct[self.machine.name] = self.machine.struct
self.machine = None
else:
self.keyworld += ch
if self.keyworld == 'module':
self.machine = module()
self.keyworld = ''
if self.keyworld == 'struct':
self.machine = struct()
self.keyworld = ''
def getmodule(self):
return self.module
def getstruct(self):
return self.struct
def syntaxanalysis(self, genfilestr):
for str in genfilestr:
for ch in str:
self.push(ch)
检索到module和struct之后分别进入对应分支。
之后是codegen的代码见:
https://github.com/NetEase/fossilizid/blob/master/juggle/rpcmake/codegen.py
和之前的http://www.cnblogs.com/qianqians/p/4184441.html对比可以看到精简之后的dsl语法要方便分析许多，实作代码也要清晰不少。
和之前为c++添加rpccall的计划相比，现在的dsl语言便于提供其他语言的扩展，同时编译器也会好些很多。
btw:现在的dsl语法非常之强类型，尤其是带模板参数的array<int>，有用过protobuf和thrift的同学应该可以对比去其中的区别，希望大家能对如何设计一个好用的dsl展开讨论。