/**
* Takes delimiter tags and sets the delimiter for the parser.
*
* @param sds tag The tag
*
* @retval sdsempty() Emtpy sds string.
*/
static sds tag_delimiter(sds tag)
{
puts("tag_delimiter");
printf("tag found: '%s'\n",tag);
sds re = sdsempty();
sds oldl = sdsdup(ldelim), oldr = sdsdup(rdelim);
re = sdscatprintf(re, "(%s=\\S+)\\s+(\\S+=%s)", oldl, oldr);
struct slre_cap caps[2];
int i;
if ((i = slre_match(re, tag, sdslen(tag), caps, 2)) > 0) {
ldelim = sdscpylen(ldelim, caps[0].ptr, caps[0].len);
rdelim = sdscpylen(rdelim, caps[1].ptr, caps[1].len);
oldl = sdscatprintf(sdsempty(), "%s=", oldl);
oldr = sdscatprintf(sdsempty(), "=%s", oldr);
ldelim = sdsreplace(ldelim, oldl, NULL);
rdelim = sdsreplace(rdelim, oldr, NULL);
printf("ldelim: '%s'\n", ldelim);
printf("rdelim: '%s'\n", rdelim);
}
printf("Matched: %d\n",i);
puts("free oldl); sdsfree(oldr); sdsfree(re");
sdsfree(oldl); sdsfree(oldr); sdsfree(re);
return sdsempty();
}
int resloveMessage(char **msg, vuiClient *c)
{
char *buf;
char *body;
int left;
buf = *msg;
body = strstr(buf, "\r\n\r\n");
if (NULL == body)return -2;//continue read //头部没有结束
body = body + 4;
c->querymsg = sdscpylen(c->querymsg, buf, body - buf);
if (0 != resolveHeader(c->querymsg, &c->prot)){
*msg = body;
return -1;
}
left = sdslen(c->querybuf) - (body - c->querybuf);
if (c->prot.lenght <= left)
{
c->querymsg = sdscatlen(c->querymsg, body, c->prot.lenght);
*msg = body + c->prot.lenght;
return 0;
}
c->prot.waiting = c->prot.lenght - left;
c->querymsg = sdscat(c->querymsg, body);
return -3;
}
sds
cursor_next_key(cursor_t *cursor)
{
const char *str;
size_t len;
sds key;
if (!leveldb_iter_valid(cursor->iter)) {
return NULL;
}
str = leveldb_iter_key(cursor->iter, &len);
key = sdscpylen(sdsempty(), str, len); /* TODO: check mem */
leveldb_iter_next(cursor->iter);
return key;
}
/**
* Replaces the string `search` with `replace` in string `sds`
*
* @param sds str The string to be manipulated
* @param sds search The search string
* @param char *replace The replacement string
*
* @retval sds str The manipulated string.
*/
static sds sdsreplace(sds str, sds search, char *replace)
{
puts("sdsreplace");
sds buff = sdsempty();
char *p;
if (!(p = strstr(str, search)))
return str;
buff = sdscatlen(buff, str, p-str);
if (replace != NULL) {
buff = sdscat(buff, replace);
}
buff = sdscat(buff, p+sdslen(search));
//sdsfree(search);
str = sdscpylen(str,buff,sdslen(buff));
puts("free buff");
//sdsfree(buff);
return str;
}
/**
* Parses a matched tag and routes it to the relevant function.
*
* @param sds tag The matched tag.
*
* @retval sds tag The parsed tag.
*/
static sds parse_tag(sds tag)
{
puts("parse_tag");
sds buff = sdsempty();
switch (tag[(strlen(ldelim))]) {
case '!':
buff = tag_comment(tag);
break;
case '>':
buff = tag_partial(tag);
break;
case '=':
buff = tag_delimiter(tag);
break;
default:
buff = tag_variable(tag);
break;
}
tag = sdscpylen(tag,buff,sdslen(buff));
puts("free buff");
//sdsfree(buff);
return tag;
}
static void redis_pack_command(lua_State *vm, const char *id, char *cmd, int len)
{
int sockfd;
struct request *req, *link;
link = linkpool_get(id);
if(link == NULL)
{
return ;
}
lua_getglobal(vm, "__USERDATA__");
sockfd = luaL_checkinteger(vm, -1);
lua_pop(vm, 1);
req = &srv.req[sockfd];
req->link = link;
req->state = REDIS_SEND;
req->handler = sockio_write;
req->buf = sdscpylen(req->buf, cmd, len);
srv.el->insert(req->link->fd, req, FDEVENT_WRITE);
}
/* Like sdscpylen() but 't' must be a null-termined string so that the length
* of the string is obtained with strlen(). */
sds sdscpy(sds s, const char *t) {
return sdscpylen(s, t, strlen(t));
}
/**
* Parses a string buffer for mustache tags.
*
* @param sds str The string buffer to parse.
*
* @retval sds str The parsed string buffer.
*/
static sds match_tags(sds str)
{
puts("match_tags");
sds re = sdsempty(), s = sdsempty(), buff = sdsempty();
re = sdscatprintf(re, "(%s[\\S\\s]+?%s)", ldelim, rdelim);
struct slre_cap caps[1];
int i, sl = sdslen(str);
struct slre_cap* match = slre_match_all(re, str, sl, caps, 1);
int matches = slre_match_count(re, str, sl, caps, 1);
sds remain = sdsdup(str);
sds part = sdsempty();
char *pos, *end, type;
for (i=0; i < matches; i++) {
s = sdsempty();
s = sdscatprintf(s,"%.*s", match[i].len, match[i].ptr);
if (!(pos = strstr(remain, s)))
continue;
part = sdscpylen(part, remain, pos-remain);
remain = sdscpy(remain, pos+sdslen(s));
buff = sdscat(buff,part);
type = s[(strlen(ldelim))];
if (type == '#' || type == '^') {
sds endtag = sdsdup(s);
sds tag = sdscpylen(
sdsempty(),
( s + sdslen(ldelim) + 1 ),
(
sdslen(s) -
sdslen(ldelim) -
sdslen(rdelim) - 1
)
);
endtag[(sdslen(ldelim))] = '/';
end = strstr(remain, endtag);
printf("part: '%s'\n", part);
s = sdscatlen(sdsempty(), remain, end-remain);
printf("search: '%s'\n", s);
remain = sdscpy(remain, end+sdslen(endtag));
printf("remain: '%s'\n", remain);
//sds tmp = sdsempty();
//tmp = match_tags(tmp);
buff = parse_section(s, tag, type);
//sdsfree(tmp);
//buff = sdscat(buff, tmp);
} else {
buff = sdscat(buff,parse_tag(s));
puts("foo");
}
}
buff = sdscat(buff,remain);
str = sdscpylen(str,buff,sdslen(buff));
puts("free part");
sdsfree(part);
puts("free remain");
sdsfree(remain);
puts("free buff");
//sdsfree(buff);
puts("free re");
sdsfree(re);
puts("free s");
// sdsfree(s);
// puts("return");
return str;
}
