void mcs_hdf_rep(HDF *data, HDF *dst) { char *srcstr, *repstr; if (!data || !dst) return; HDF *datarow = hdf_obj_child(data); while (datarow) { HDF *child = hdf_obj_child(dst); while (child) { if (hdf_obj_child(child)) { return mcs_hdf_rep(data, child); } srcstr = hdf_obj_value(child); repstr = mstr_repstr(1, srcstr, hdf_obj_name(datarow), hdf_obj_value(datarow)); hdf_set_value(child, NULL, repstr); free(repstr); child = hdf_obj_next(child); } datarow = hdf_obj_next(datarow); } }
void mjson_asm_objs(HDF *hdf, struct json_object **out) { if (hdf == NULL) return; struct json_object *jret, *jso; char *val, *type; bool array = false; type = mcs_obj_attr(hdf, "type"); if (type && !strcmp(type, "array")) { array = true; jret = json_object_new_array(); } else { jret = json_object_new_object(); } hdf = hdf_obj_child(hdf); while (hdf) { jso = NULL; if ((val = hdf_obj_value(hdf)) != NULL) { type = mcs_obj_attr(hdf, "type"); if (type != NULL && !strcmp(type, "int")) { jso = json_object_new_int(atoi(val)); } else { jso = json_object_new_string(val); } if (array) json_object_array_add(jret, jso); else json_object_object_add(jret, hdf_obj_name(hdf), jso); } if (hdf_obj_child(hdf) != NULL) { mjson_asm_objs(hdf, &jso); if (array) json_object_array_add(jret, jso); else json_object_object_add(jret, hdf_obj_name(hdf), jso); } hdf = hdf_obj_next(hdf); } *out = jret; }
NEOERR* inbox_multi_add(HDF *datanode, HASH *evth, char *inboxtype) { mevent_t *evt; int mid; HDF *child; NEOERR *err; MCS_NOT_NULLB(datanode, evth); evt = hash_lookup(evth, "aux"); MCS_NOT_NULLA(evt); child = hdf_obj_child(datanode); while (child) { mid = hdf_get_int_value(child, "mid", 0); if (mid > 0) { hdf_set_valuef(evt->hdfsnd, "mmid.%d=%d", mid, mid); } child = hdf_obj_next(child); } if (!hdf_get_obj(evt->hdfsnd, "mmid")) return nerr_raise(NERR_ASSERT, "请设置收信用户号码"); err = mtpl_InConfigRend_get(evt->hdfsnd, datanode, "inbox", inboxtype, g_datah); if (err != STATUS_OK) return nerr_pass(err); MEVENT_TRIGGER(evt, NULL, REQ_CMD_AUX_INBOX_ADD, FLAGS_NONE); return STATUS_OK; }
bool Tree::ParseFromHdfFile(const std::string &filename) { Clear(); HDF *hdf; NEOERR *err = hdf_init(&hdf); if (err != STATUS_OK) { nerr_ignore(&err); return false; } err = hdf_read_file(hdf, filename.c_str()); if (err != STATUS_OK) { nerr_ignore(&err); hdf_destroy(&hdf); return false; } HDF *child = hdf_obj_child(hdf); if (!child) { hdf_destroy(&hdf); return false; } if (!ParseFromHdfInternal(child)) { hdf_destroy(&hdf); return false; } hdf_destroy(&hdf); return true; }
bool Tree::ParseFromHdfString(const std::string &serialized) { Clear(); if (serialized.empty()) { return true; } HDF *hdf; NEOERR *err = hdf_init(&hdf); if (err != STATUS_OK) { nerr_ignore(&err); return false; } err = hdf_read_string(hdf, serialized.c_str()); if (err != STATUS_OK) { nerr_ignore(&err); hdf_destroy(&hdf); return false; } HDF *child = hdf_obj_child(hdf); if (!child) { hdf_destroy(&hdf); return false; } if (!ParseFromHdfInternal(child)) { hdf_destroy(&hdf); return false; } hdf_destroy(&hdf); return true; }
NEOERR* levt_init(HASH **evth) { mevent_t *evt; char *ename; HDF *node; HASH *levth; NEOERR *err; node = hdf_get_obj(g_cfg, "Mevent"); if (!node) return nerr_raise(NERR_ASSERT, "Mevent config not found"); err = hash_init(&levth, hash_str_hash, hash_str_comp, hash_str_free); if (err != STATUS_OK) return nerr_pass(err); node = hdf_obj_child(node); while (node != NULL) { ename = hdf_obj_value(node); evt = mevent_init_plugin(ename); if (evt) { mtc_dbg("event %s init ok", ename); hash_insert(levth, (void*)strdup(ename), (void*)evt); } else { mtc_err("event %s init failure", ename); } node = hdf_obj_next(node); } *evth = levth; return STATUS_OK; }
void CGI::TranslatePost(void *cgi, Tree *posts, std::map<std::string, File> *files) { ::CGI *c = reinterpret_cast< ::CGI *>(cgi); HDF *parent = hdf_get_obj(c->hdf, "Query"); if (!parent) { return; } HDF *next = hdf_obj_child(parent); while (next) { HDF *child = next; next = hdf_obj_next(next); const char *k = hdf_obj_name(child); const char *v = hdf_obj_value(child); if (!k || !v) { continue; } if (!TranslateFile(c, k, files)) { posts->Set(k, v); } } }
NEOERR* fill_trackarea(HASH *evth, HASH *dbh) { mdb_conn *conn = (mdb_conn*)hash_lookup(dbh, "dyn"); mevent_t *evt = (mevent_t*)hash_lookup(evth, "place"); HDF *node; hdf_init(&node); char *ip, *aid, *uid, *city, *area; NEOERR *err; LPRE_ALLOP(node, conn, evt); MDB_QUERY_RAW(conn, "track", COL_TRACK, "intime > current_date AND " " area='' GROUP BY aid, uid", NULL); err = mdb_set_rows(node, conn, COL_TRACK, NULL, NULL); if (err != STATUS_OK) return nerr_pass(err); node = hdf_obj_child(node); while (node) { ip = hdf_get_value(node, "ip", NULL); aid = hdf_get_value(node, "aid", "0"); uid = hdf_get_value(node, "uid", "0"); if (ip) { hdf_set_value(evt->hdfsnd, "ip", ip); MEVENT_TRIGGER_NRET(evt, ip, REQ_CMD_PLACEGET, FLAGS_SYNC); city = hdf_get_value(evt->hdfrcv, "0.c", "Mars"); area = city2area(city); MDB_EXEC(conn, NULL, "UPDATE track SET area=$1 WHERE aid=$2 AND uid=$3", "sss", area, aid, uid); } node = hdf_obj_next(node); } return STATUS_OK; }
JNIEXPORT jint JNICALL Java_org_clearsilver_HDF__1objChild( JNIEnv *env, jclass objClass, jint hdf_obj_ptr) { HDF *hdf = (HDF *)hdf_obj_ptr; HDF *child_hdf = NULL; child_hdf = hdf_obj_child(hdf); return (jint)child_hdf; }
Hdf Hdf::firstChild(bool markVisited /* = true */) const { HDF *hdf = getRaw(); if (markVisited) hdf_set_visited(hdf, 1); Hdf ret(hdf_obj_child(hdf)); ret.m_path = getFullPath(); ret.m_name = ret.getName(markVisited); return ret; }
int wkm_cfg_to_opts(struct wkman *wkman, struct cfg *cfg) { HDF *base_hdf = (HDF*)cfg; HDF *hdf; int rval = 0; dbg1("%s %s()", wkman->dev->serial, __func__); for(hdf = hdf_obj_child(base_hdf); hdf; hdf = hdf_obj_next(hdf)) { const char *key = hdf_obj_name(hdf); const char *val_str = hdf_obj_value(hdf); int val = atoi(val_str); rval += wkm_set_value(wkman, key, val); } return rval; }
HDF* mcs_obj_nth_child(HDF *hdf, int n) { HDF *node; if (!hdf || n < 0) return NULL; node = hdf_obj_child(hdf); while (node && --n > 0) { node = hdf_obj_next(node); } return node; }
int main(int argc, char **argv, char **envp) { char key[10]; HDF *bignode; mtc_init("cshdf", 7); hdf_init(&bignode); for (int i = 0; i < 5003929; i++) { mstr_rand_string_with_len(key, 10); hdf_set_valuef(bignode, "%s.today=10", key); hdf_set_valuef(bignode, "%s.toweek=11", key); hdf_set_valuef(bignode, "%s.tomonth=12", key); hdf_set_valuef(bignode, "%s.total=234", key); if (i % 10000 == 0) printf("%d\n", i); } //hdf_dump(bignode, NULL); printf("child num %d\n", mcs_get_child_num(bignode, NULL)); int count = 0; mtimer_start(); HDF *cnode = hdf_obj_child(bignode); while (cnode) { char *name = hdf_obj_name(cnode); if (mcs_get_int_valuef(bignode, 0, "%s.today", name) != 10) printf("error\n"); if (mcs_get_int_valuef(bignode, 0, "%s.toweek", name) != 11) printf("error\n"); if (mcs_get_int_valuef(bignode, 0, "%s.tomonth", name) != 12) printf("error\n"); if (mcs_get_int_valuef(bignode, 0, "%s.total", name) != 234) printf("error\n"); count++; cnode = hdf_obj_next(cnode); } mtimer_stop("get time"); printf("get child count %d\n", count); hdf_destroy(&bignode); return 0; }
NEOERR* ldml_parse_file(char *dir, char *name, HASH *outhash) { char fname[_POSIX_PATH_MAX], *attrval = NULL; HDF *node, *child, *dhdf; STRING str; NEOERR *err; memset(fname, 0x0, sizeof(fname)); snprintf(fname, sizeof(fname), "%s/%s", dir, name); err = hdf_init(&node); if (err != STATUS_OK) return nerr_pass(err); err = hdf_read_file(node, fname); if (err != STATUS_OK) return nerr_pass(err); child = hdf_obj_child(node); while (child != NULL) { mtc_dbg("parse node %s", hdf_obj_name(child)); string_init(&str); attrval = mcs_obj_attr(child, "merge"); if (attrval) { ULIST *list; string_array_split(&list, attrval, ",", 10); ITERATE_MLIST(list) { snprintf(fname, sizeof(fname), "%s/%s", dir, neos_strip((char*)list->items[t_rsv_i])); err = hdf_init(&dhdf); JUMP_NOK(err, wnext); err = hdf_read_file(dhdf, fname); JUMP_NOK(err, wnext); err = hdf_copy(child, NULL, dhdf); JUMP_NOK(err, wnext); } uListDestroy(&list, ULIST_FREE); } wnext: string_clear(&str); child = hdf_obj_next(child); } err = hash_insert(outhash, (void*)strdup(name), (void*)node); JUMP_NOK(err, wnext); return STATUS_OK; }
static PyObject * p_hdf_obj_child (PyObject *self, PyObject *args) { HDFObject *ho = (HDFObject *)self; PyObject *rv; HDF *r; r = hdf_obj_child (ho->data); if (r == NULL) { rv = Py_None; Py_INCREF(rv); return rv; } rv = p_hdf_to_object (r, 0); return rv; }
int mmg_get_int_valuef(mmg_conn *db, char *dsn, char *key, int skip, int limit, char *qfmt, ...) { HDF *tmpnode; hdf_init(&tmpnode); char *querys, sels[256]; int val; va_list ap; HDF *node; NEOERR *err; va_start(ap, qfmt); querys = vsprintf_alloc(qfmt, ap); va_end(ap); if (!querys) { mtc_err("Unable to allocate mem for query string"); return 0; } snprintf(sels, sizeof(sels), "{'%s': 1}", key); err = mmg_prepare(db, MMG_FLAG_EMPTY, skip, limit, NULL, sels, querys); RETURN_V_NOK(err, 0); err = mmg_query(db, dsn, NULL, tmpnode); RETURN_V_NOK(err, 0); val = 0; if(hdf_get_valuef(tmpnode, "0.%s", key)) { node = hdf_obj_child(tmpnode); while (node) { val += hdf_get_int_value(node, key, 0); node = hdf_obj_next(node); } } else { val = hdf_get_int_value(tmpnode, key, 0); } hdf_destroy(&tmpnode); SAFE_FREE(querys); return val; }
void CGI::TranslateHDF(void *cgi, const std::string &node, Tree *maps) { ::CGI *c = reinterpret_cast< ::CGI *>(cgi); HDF *parent = hdf_get_obj(c->hdf, node.c_str()); if (!parent) { return; } HDF *child = hdf_obj_child(parent); while (child) { const char *k = hdf_obj_name(child); const char *v = hdf_obj_value(child); if (k && v) { maps->Set(k, v); } child = hdf_obj_next(child); } }
bool Tree::ParseFromHdfInternal(struct _hdf *hdf) { while (hdf) { const char *key = hdf_obj_name(hdf); const char *value = hdf_obj_value(hdf); if (!value) { value = ""; } std::string full_path = GetFullPath(key); Tree *child = new Tree(full_path, key, value); _children.insert(std::make_pair(key, child)); HDF *hc = hdf_obj_child(hdf); if (!child->ParseFromHdfInternal(hc)) { return false; } hdf = hdf_obj_next(hdf); } return true; }
void smsalarm_msg(char *msg) { mdb_conn *db; //char content[100]; NEOERR *err; err = mdb_init(&db, SMSA_DB_SN); RETURN_NOK(err); HDF *node = hdf_get_obj(g_cfg, SMSA_CFG_PATH".leader"); if (node != NULL) node = hdf_obj_child(node); while (node != NULL) { //memset(content, 0x0, sizeof(content)); err = mdb_exec(db, NULL, "INSERT INTO monitor_smssend (smsSendTo, smsContent) VALUES ('%s', '%s')", NULL, hdf_obj_value(node), msg); TRACE_NOK(err); node = hdf_obj_next(node); } mdb_destroy(db); }
NEOERR* email_multi_add(HDF *datanode, HASH *evth, char *emailtype) { mevent_t *evt; char *mname; HDF *child; int cnt = 0; NEOERR *err; MCS_NOT_NULLB(datanode, evth); evt = hash_lookup(evth, "aux"); MCS_NOT_NULLA(evt); child = hdf_obj_child(datanode); while (child) { mname = hdf_get_value(child, "mname", NULL); if (mname) { /* * use cnt instead of mname as hdf key because mname contain '.' */ hdf_set_valuef(evt->hdfsnd, "mto.%d=%s", cnt++, mname); } child = hdf_obj_next(child); } if (!hdf_get_obj(evt->hdfsnd, "mto")) return nerr_raise(NERR_ASSERT, "请设置收信用户名"); err = mtpl_InConfigRend_get(evt->hdfsnd, datanode, "email", emailtype, g_datah); if (err != STATUS_OK) return nerr_pass(err); MEVENT_TRIGGER(evt, NULL, REQ_CMD_AUX_EMAIL_ADD, FLAGS_NONE); return STATUS_OK; }
static NEOERR* _hdf_read_string (HDF *hdf, const char **str, STRING *line, const char *path, int *lineno, int include_handle, int expect_end_brace) { NEOERR *err; HDF *lower; char *s; char *name, *value; HDF_ATTR *attr = NULL; while (**str != '\0') { /* Reset string length, but don't free the reserved buffer */ line->len = 0; err = _copy_line_advance(str, line); if (err) return nerr_pass(err); attr = NULL; (*lineno)++; s = line->buf; SKIPWS(s); if ((!strncmp(s, "#include ", 9) || !strncmp(s, "-include ", 9)) && include_handle != INCLUDE_IGNORE) { int required = !strncmp(s, "#include ", 9); if (include_handle == INCLUDE_ERROR) { return nerr_raise (NERR_PARSE, "[%d]: #include not supported in string parse", *lineno); } else if (include_handle < INCLUDE_MAX_DEPTH) { int l; s += 9; name = neos_strip(s); l = strlen(name); if (name[0] == '"' && name[l-1] == '"') { name[l-1] = '\0'; name++; } char fullpath[PATH_MAX]; if (name[0] != '/') { memset(fullpath, 0, PATH_MAX); char *p = strrchr(path, '/'); if (p == NULL) { char pwd[PATH_MAX]; memset(pwd, 0, PATH_MAX); getcwd(pwd, PATH_MAX); snprintf(fullpath, PATH_MAX, "%s/%s", pwd, name); } else { int dir_len = p - path + 1; snprintf(fullpath, PATH_MAX, "%s", path); snprintf(fullpath + dir_len, PATH_MAX - dir_len, "%s", name); } name = fullpath; } err = hdf_read_file_internal(hdf, name, include_handle + 1); if (err != STATUS_OK && required) { return nerr_pass_ctx(err, "In file %s:%d", path, *lineno); } } else { return nerr_raise (NERR_MAX_RECURSION, "[%d]: Too many recursion levels.", *lineno ); } } else if (s[0] == '#') { /* comment: pass */ } else if (s[0] == '}') /* up */ { s = neos_strip(s); if (strcmp(s, "}")) { err = nerr_raise(NERR_PARSE, "[%s:%d] Trailing garbage on line following }: %s", path, *lineno, line->buf); return err; } return STATUS_OK; } else if (s[0]) { /* Valid hdf name is [0-9a-zA-Z_.]+ */ int splice = *s == '@'; if (splice) s++; name = s; while (*s && (isalnum(*s) || *s == '_' || *s == '.' || *s == '*')) s++; SKIPWS(s); char num[16]; static int counter = 0; if (*name == '*') { snprintf(num, sizeof(num), "%d", counter++); name = num; } if (s[0] == '[') /* attributes */ { *s = '\0'; name = neos_strip(name); s++; err = parse_attr(&s, &attr); if (err) { return nerr_pass_ctx(err, "In file %s:%d", path, *lineno); } SKIPWS(s); } if (splice) { name = neos_strip(name); HDF *h = hdf_get_obj(hdf->top, name); if (h) { HDF *c = hdf_obj_child(h); while (c) { err = hdf_copy (hdf, hdf_obj_name(c), c); if (err != STATUS_OK) break; c = hdf_obj_next(c); } } if (err != STATUS_OK) { return nerr_pass_ctx(err, "In file %s:%d", path, *lineno); } } else if (s[0] == '=') /* assignment */ { *s = '\0'; name = neos_strip(name); s++; value = neos_strip(s); err = _set_value (hdf, name, value, 1, 1, 0, attr, NULL); if (err != STATUS_OK) { return nerr_pass_ctx(err, "In file %s:%d", path, *lineno); } } else if (s[0] == ':' && s[1] == '=') /* copy */ { *s = '\0'; name = neos_strip(name); s+=2; value = neos_strip(s); HDF *h = hdf_get_obj(hdf->top, value); if (!h) { err = nerr_raise(NERR_PARSE, "[%s:%d] Failed to copy a node that is not loaded " "yet: %s", path, *lineno, value); return err; } err = hdf_copy(hdf, name, h); if (err != STATUS_OK) { return nerr_pass_ctx(err, "In file %s:%d", path, *lineno); } } else if (s[0] == '!' && s[1] == '=') /* exec */ { *s = '\0'; name = neos_strip(name); s+=2; value = neos_strip(s); FILE *f = popen(value, "r"); if (f == NULL) { err = nerr_raise(NERR_PARSE, "[%s:%d] Failed to exec specified command: %s", path, *lineno, line->buf); return err; } char *content = _read_file(f); fclose(f); int len = strlen(content); if (len > 0 && content[len - 1] == '\n') { content[len - 1] = '\0'; // remove \n artifact } err = _set_value (hdf, name, content, 1, 1, 0, attr, NULL); free(content); if (err != STATUS_OK) { return nerr_pass_ctx(err, "In file %s:%d", path, *lineno); } } else if (s[0] == ':') /* link */ { *s = '\0'; name = neos_strip(name); s++; value = neos_strip(s); err = _set_value (hdf, name, value, 1, 1, 1, attr, NULL); if (err != STATUS_OK) { return nerr_pass_ctx(err, "In file %s:%d", path, *lineno); } } else if (s[0] == '{') /* deeper */ { *s = '\0'; name = neos_strip(name); lower = hdf_get_obj (hdf, name); if (lower == NULL) { err = _set_value (hdf, name, NULL, 1, 1, 0, attr, &lower); } else { err = _set_value (lower, NULL, lower->value, 1, 1, 0, attr, NULL); } if (err != STATUS_OK) { return nerr_pass_ctx(err, "In file %s:%d", path, *lineno); } err = _hdf_read_string (lower, str, line, path, lineno, include_handle, 1); if (err != STATUS_OK) { return nerr_pass_ctx(err, "In file %s:%d", path, *lineno); } } else if (s[0] == '<' && s[1] == '<') /* multi-line assignment */ { char *m; int msize = 0; int mmax = 128; int l; *s = '\0'; name = neos_strip(name); s+=2; value = neos_strip(s); l = strlen(value); if (l == 0) { err = nerr_raise(NERR_PARSE, "[%s:%d] No multi-assignment terminator given: %s", path, *lineno, line->buf); return err; } m = (char *) malloc (mmax * sizeof(char)); if (m == NULL) { return nerr_raise(NERR_NOMEM, "[%s:%d] Unable to allocate memory for multi-line assignment to %s", path, *lineno, name); } while (_copy_line (str, m+msize, mmax-msize) != 0) { (*lineno)++; if (!strncmp(value, m+msize, l) && isspace(m[msize+l])) { m[msize] = '\0'; break; } msize += strlen(m+msize); if (msize + l + 10 > mmax) { void *new_ptr; mmax += 128; new_ptr = realloc (m, mmax * sizeof(char)); if (new_ptr == NULL) { free(m); return nerr_raise(NERR_NOMEM, "[%s:%d] Unable to allocate memory for multi-line assignment to %s: size=%d", path, *lineno, name, mmax); } m = (char *) new_ptr; } } err = _set_value (hdf, name, m, 0, 1, 0, attr, NULL); if (err != STATUS_OK) { free (m); return nerr_pass_ctx(err, "In file %s:%d", path, *lineno); } } else { err = nerr_raise(NERR_PARSE, "[%s:%d] Unable to parse line %s", path, *lineno, line->buf); return err; } } } if (expect_end_brace) { err = nerr_raise(NERR_PARSE, "[%s:%d] Missing matching }", path, *lineno); return err; } return STATUS_OK; }
static void ips2places(HDF *hdf, HASH *evth) { if (!hdf || !evth) return; mevent_t *evt = (mevent_t*)hash_lookup(evth, "place"); mevent_t *evta = (mevent_t*)hash_lookup(evth, "aic"); if (!evt || !evta) { mtc_err("can't find event"); return; } char *p, *q; HDF *node, *rnode; STRING ip; string_init(&ip); node = hdf_obj_child(hdf); while (node) { p = hdf_get_value(node, "ip", NULL); q = hdf_get_value(node, "addr", NULL); if (p && (!q || !*q)) string_appendf(&ip, "%s,", p); node = hdf_obj_next(node); } if (ip.len <= 0) return; hdf_set_value(evt->hdfsnd, "ip", ip.buf); MEVENT_TRIGGER_VOID(evt, ip.buf, REQ_CMD_PLACEGET, FLAGS_SYNC); if (evt->hdfrcv) { node = hdf_obj_child(hdf); while (node) { rnode = hdf_obj_child(evt->hdfrcv); p = hdf_get_value(node, "ip", NULL); q = hdf_get_value(node, "addr", NULL); if (p && (!q || !*q)) { while (rnode) { q = hdf_get_value(rnode, "ip", NULL); if (q && !strcmp(p, q)) break; else q = NULL; rnode = hdf_obj_next(rnode); } if (q) { hdf_set_value(node, "addr", hdf_get_value(rnode, "c", NULL)); hdf_set_value(node, "area", hdf_get_value(rnode, "a", NULL)); hdf_set_value(evta->hdfsnd, "uid", hdf_get_value(node, "uid", 0)); hdf_set_value(evta->hdfsnd, "aid", hdf_get_value(node, "aid", 0)); hdf_set_value(evta->hdfsnd, "addr", hdf_get_value(rnode, "c", "Mars")); MEVENT_TRIGGER_NRET(evta, NULL, REQ_CMD_APPUSERUP, FLAGS_NONE); } else { mtc_warn("can't find addr for %s", p); } } node = hdf_obj_next(node); } } string_clear(&ip); }
static int mevent_start_driver(struct mevent *evt, struct event_driver *d, void *lib, int num_thread, HDF *matenode) { if (evt == NULL || evt->table == NULL || d == NULL) return 0; struct event_entry *e = d->init_driver(); if (e == NULL) return 0; num_thread = num_thread < 0 ? 1 : num_thread; if (num_thread > MAX_THREAD_NUM) { wlog("plugin %s thread number %d too large, set to default max number %d", e->name, num_thread, MAX_THREAD_NUM); mtc_warn("plugin %s thread number %d too large, set to default max number %d", e->name, num_thread, MAX_THREAD_NUM); num_thread = MAX_THREAD_NUM; } e->num_thread = num_thread; e->cur_thread = 0; for (int i = 0; i < num_thread; i++) { e->op_queue[i] = queue_create(); e->op_thread[i] = malloc(sizeof(pthread_t)); pthread_create(e->op_thread[i], NULL, mevent_start_base_entry, (void*)e); sleep(1); e->cur_thread++; } e->cur_thread = 0; HDF *cnode = hdf_obj_child(matenode); char *dle; for (int i = 0; cnode && i < MAX_THREAD_NUM; cnode = hdf_obj_next(cnode)) { void* (*mate_func)(void *arg); mate_func = dlsym(lib, hdf_obj_value(cnode)); if ((dle = dlerror()) != NULL) { wlog("unable to find %s %s", hdf_obj_value(cnode), dle); mtc_err("unable to find %s %s", hdf_obj_value(cnode), dle); continue; } e->mt_thread[i] = malloc(sizeof(pthread_t)); pthread_create(e->mt_thread[i], NULL, mate_func, (void*)e); i++; } uint32_t h; struct event_chain *c; h = hash(e->name, e->ksize) % evt->hashlen; c = evt->table + h; if (c->len == 0) { c->first = e; c->last = e; c->len = 1; } else if (c->len <= evt->chainlen) { e->next = c->first; c->first->prev = e; c->first = e; c->len += 1; } else { wlog("unbelieveable, you have more than %d plugins, stop it %s", evt->chainlen, e->name); mtc_warn("unbelieveable, you have more than %ld plugins, stop it %s", evt->chainlen, e->name); mevent_stop_driver(e); return 0; } return 1; }
NEOERR* ltpl_parse_file(HASH *dbh, void *lib, char *dir, char *name, HASH *outhash) { char *tp = NULL, *tpl = NULL, *val = NULL; HDF *node = NULL, *dhdf = NULL, *child = NULL; CSPARSE *cs = NULL; STRING str; char fname[_POSIX_PATH_MAX], tok[64]; NEOERR* (*data_handler)(HDF *hdf, HASH *dbh); NEOERR *err; memset(fname, 0x0, sizeof(fname)); snprintf(fname, sizeof(fname), "%s/%s", dir, name); err = hdf_init(&node); if (err != STATUS_OK) return nerr_pass(err); err = hdf_read_file(node, fname); if (err != STATUS_OK) return nerr_pass(err); child = hdf_obj_child(node); while (child != NULL) { mtc_dbg("parse node %s", hdf_obj_name(child)); string_init(&str); val = mutil_obj_attr(child, "merge"); if (val) { snprintf(fname, sizeof(fname), "%s/%s", dir, val); err = hdf_init(&dhdf); JUMP_NOK(err, wnext); err = hdf_read_file(dhdf, fname); JUMP_NOK(err, wnext); err = hdf_copy(child, NULL, dhdf); JUMP_NOK(err, wnext); } err = cs_init(&cs, hdf_get_obj(child, PRE_CFG_DATASET)); JUMP_NOK(err, wnext); hdf_set_value(cs->hdf, "hdf.loadpaths.local", dir); err = cgi_register_strfuncs(cs); JUMP_NOK(err, wnext); err = mcs_register_bitop_functions(cs); JUMP_NOK(err, wnext); err = mcs_register_mkd_functions(cs); JUMP_NOK(err, wnext); tpl = hdf_get_value(child, PRE_CFG_LAYOUT, "null.html"); snprintf(fname, sizeof(fname), "%s/%s", PATH_TPL, tpl); err = cs_parse_file(cs, fname); JUMP_NOK(err, wnext); if (outhash != NULL) { /* * strdup the key, baby, because we'll free the hdf later */ err = hash_insert(outhash, (void*)strdup(hdf_obj_name(child)), (void*)cs); JUMP_NOK(err, wnext); if (hdf_get_obj(child, PRE_CFG_DATASET)) { err = hdf_init(&dhdf); JUMP_NOK(err, wnext); err = hdf_copy(dhdf, NULL, hdf_get_obj(child, PRE_CFG_DATASET)); JUMP_NOK(err, wnext); snprintf(tok, sizeof(tok), "%s_hdf", hdf_obj_name(child)); err = hash_insert(outhash, (void*)strdup(tok), (void*)dhdf); JUMP_NOK(err, wnext); } } if (hdf_get_value(child, PRE_CFG_OUTPUT, NULL) != NULL) { ltpl_prepare_rend(hdf_get_obj(child, PRE_CFG_DATASET), tpl); /* * get_data */ val = hdf_get_value(child, PRE_CFG_DATAER, NULL); if (val != NULL && lib) { data_handler = dlsym(lib, val); if( (tp = dlerror()) != NULL) { mtc_err("%s", tp); //continue; } else { err = (*data_handler)(hdf_get_obj(child, PRE_CFG_DATASET), dbh); TRACE_NOK(err); } } err = cs_render(cs, &str, mcs_strcb); JUMP_NOK(err, wnext); snprintf(fname, sizeof(fname), PATH_DOC"%s", hdf_get_value(child, PRE_CFG_OUTPUT, "null.html")); err = mutil_makesure_dir(fname); JUMP_NOK(err, wnext); err = mcs_str2file(str, fname); JUMP_NOK(err, wnext); #ifdef DEBUG_HDF snprintf(fname, sizeof(fname), "%s/hdf.%s", TC_ROOT, hdf_obj_name(child)); hdf_write_file(child, fname); #endif } wnext: if (cs != NULL && outhash == NULL) cs_destroy(&cs); string_clear(&str); child = hdf_obj_next(child); } if (node != NULL) hdf_destroy(&node); return STATUS_OK; }
NEOERR* ltpl_parse_file(HASH *dbh, HASH *evth, void *lib, char *dir, char *name, HASH *outhash) { char *tp = NULL, *tpl = NULL, *val = NULL; HDF *node = NULL, *dhdf = NULL, *child = NULL, *thdf = NULL; CSPARSE *cs = NULL; STRING str; char fname[_POSIX_PATH_MAX], tok[64], *outfile; NEOERR* (*data_handler)(HDF *hdf, HASH *dbh, HASH *evth); NEOERR *err; memset(fname, 0x0, sizeof(fname)); snprintf(fname, sizeof(fname), "%s/%s", dir, name); err = hdf_init(&node); if (err != STATUS_OK) return nerr_pass(err); err = hdf_read_file(node, fname); if (err != STATUS_OK) return nerr_pass(err); child = hdf_obj_child(node); while (child != NULL) { mtc_dbg("parse node %s", hdf_obj_name(child)); string_init(&str); val = mcs_obj_attr(child, "merge"); if (val) { ULIST *list; string_array_split(&list, val, ",", 10); ITERATE_MLIST(list) { snprintf(fname, sizeof(fname), "%s/%s", dir, neos_strip((char*)list->items[t_rsv_i])); err = hdf_init(&dhdf); JUMP_NOK(err, wnext); err = hdf_read_file(dhdf, fname); JUMP_NOK(err, wnext); err = hdf_copy(child, NULL, dhdf); JUMP_NOK(err, wnext); } uListDestroy(&list, ULIST_FREE); } /* * can't use dataset directly, because we'll destroy the whole node */ err = hdf_init(&dhdf); JUMP_NOK(err, wnext); err = hdf_get_node(child, PRE_CFG_DATASET, &thdf); JUMP_NOK(err, wnext); err = hdf_copy(dhdf, NULL, thdf); JUMP_NOK(err, wnext); err = cs_init(&cs, dhdf); JUMP_NOK(err, wnext); hdf_set_value(cs->hdf, "hdf.loadpaths.tpl", PATH_TPL); hdf_set_value(cs->hdf, "hdf.loadpaths.local", dir); err = cgi_register_strfuncs(cs); JUMP_NOK(err, wnext); err = mcs_register_bitop_functions(cs); JUMP_NOK(err, wnext); err = mcs_register_mkd_functions(cs); JUMP_NOK(err, wnext); err = mcs_register_string_uslice(cs); JUMP_NOK(err, wnext); tpl = hdf_get_value(child, PRE_CFG_LAYOUT, "null.html"); snprintf(fname, sizeof(fname), "%s/%s", PATH_TPL, tpl); err = cs_parse_file(cs, fname); JUMP_NOK(err, wnext); if (outhash != NULL) { /* * store template for rend stage use */ hdf_set_value(cs->hdf, PRE_RESERVE"."PRE_CFG_LAYOUT, tpl); /* * strdup the key, baby, because we'll free the hdf later */ err = hash_insert(outhash, (void*)strdup(hdf_obj_name(child)), (void*)cs); JUMP_NOK(err, wnext); snprintf(tok, sizeof(tok), "%s_hdf", hdf_obj_name(child)); err = hash_insert(outhash, (void*)strdup(tok), (void*)cs->hdf); JUMP_NOK(err, wnext); } if ((outfile = hdf_get_value(child, PRE_CFG_OUTPUT, NULL)) != NULL) { ltpl_prepare_rend(cs->hdf, tpl); /* * get_data */ val = hdf_get_value(child, PRE_CFG_DATAER, NULL); if (val != NULL && lib) { data_handler = dlsym(lib, val); if( (tp = dlerror()) != NULL) { mtc_err("%s", tp); //continue; } else { err = (*data_handler)(cs->hdf, dbh, evth); TRACE_NOK(err); } } err = cs_render(cs, &str, mcs_strcb); JUMP_NOK(err, wnext); /* * produce output filename */ val = mcs_hdf_attr(child, PRE_CFG_OUTPUT, "ftime"); if (val) { char tm[LEN_TM]; mutil_getdatetime(tm, sizeof(tm), val, 0); outfile = mstr_repstr(1, outfile, "$ftime$", tm); } snprintf(fname, sizeof(fname), PATH_DOC"%s", outfile); /* * output file */ err = mfile_makesure_dir(fname); JUMP_NOK(err, wnext); err = mcs_str2file(str, fname); JUMP_NOK(err, wnext); #ifdef DEBUG_HDF snprintf(fname, sizeof(fname), "%s/hdf.%s", TC_ROOT, hdf_obj_name(child)); hdf_write_file(child, fname); #endif } wnext: if (cs != NULL && outhash == NULL) cs_destroy(&cs); string_clear(&str); child = hdf_obj_next(child); } if (node != NULL) hdf_destroy(&node); return STATUS_OK; }