void create() { ::create(); /* OBJEDIT { */ set_name( "bear skin" ); set_gettable( 1 ); set_droppable( 1 ); set_height( 5 ); set_weight( 2000 ); set_bulk( 1800 ); set_value( 70 ); /* } OBJEDIT */ }
create() { ::create(); /* OBJEDIT { */ set_drinkable( 1 ); set_weight( 1000 ); set_bulk( 1000 ); set_value( 5 ); set_distant( "milk" ); set_specific( "the milk" ); set_look( "Cool and creamy, white and frothy milk." ); set_plural( "milk" ); set_name( "milk" ); set_use_msg( "~Name ~verbchug the cool, frothy milk leaving a nice white mustache." ); /* } OBJEDIT */ }
/** Collect all information about a process * * The psinfo variable is so that /proc/<pid>/psinfo only needs to be read * once. */ struct psi_process * psi_arch_process(const pid_t pid) { struct psi_process *proci; struct procentry64 procent; int r; r = getprocent(&procent, pid); if (r < 0) return NULL; proci = psi_calloc(sizeof(struct psi_process)); if (proci == NULL) return NULL; if (set_bulk(proci, &procent) < 0) return psi_free_process(proci); if (set_args(proci, &procent) < 0) return psi_free_process(proci); if (set_env(proci, &procent) < 0) return psi_free_process(proci); if (set_cwd(proci, &procent) < 0) return psi_free_process(proci); return proci; }
create() { ::create(); /* OBJEDIT { */ set_edible( 1 ); set_food_value( 10 ); set_drink_value( 2 ); // Per 1000 units set_weight( 1500 ); set_bulk( 1000 ); set_value( 0 ); set_distant( "dough" ); set_specific( "the dough" ); set_look( "A pale brown glob of raw dough." ); set_plural( "dough" ); set_name( "dough" ); set_use_msg( "~Name ~verbgulp down some raw dough." ); set_quantity( 250 ); set_solid( 1 ); set_gettable( 1 ); set_droppable( 1 ); /* } OBJEDIT */ call_out( "rise", 60 ); state = 0; // Unraised cooked = 0; }
char *ldb_values(struct _leveldb_stuff *ldbs, const char *ptn, size_t ptn_len, int *size) { char *err = NULL; char *result = NULL; char *p_dst = NULL; char *p_key = NULL; char *p_value = NULL; size_t klen = 0; size_t vlen = 0; int index = 0; int i, j, z = 0; struct kv_list list = { 0 }; struct some_kv *p_new, *p_old, *p_tmp = NULL; leveldb_iterator_t* iter = leveldb_create_iterator(ldbs->db, ldbs->roptions); leveldb_iterator_t* iter_save = iter; if (!!leveldb_iter_valid(iter)) {/* first use it is invalid */ fprintf(stderr, "%s:%d: this iter is valid already!\n", __FILE__, __LINE__); *size = -1; return NULL ; } leveldb_iter_seek_to_first(iter); p_old = p_new = &list.head; while (leveldb_iter_valid(iter)) { /* parse kv */ p_key = (char *) leveldb_iter_key(iter, &klen); log_debug("%p iter key = %s, klen = %ld\n", p_key, p_key, klen); p_value = (char *) leveldb_iter_value(iter, &vlen); leveldb_iter_get_error(iter, &err); if (err) { goto FAIL_ITER_PARSE; } if (!string_match_len(ptn, ptn_len, p_value, vlen, 0)) { leveldb_iter_next(iter); continue; } /* save parse */ list.count++;/* kv counts */ list.klens += klen; list.knubs += get_number_len(klen); index = list.count % SOME_KV_NODES_COUNT; if ((list.count / SOME_KV_NODES_COUNT >= 1) && (index == 1)) { /* new store */ p_new = malloc(sizeof(struct some_kv)); if (p_new == NULL ) { /* free store */ index = GET_NEED_COUNT( list.count, SOME_KV_NODES_COUNT ); p_tmp = &list.head; for (i = 0, z = list.count - 1; (i < index) && (p_tmp != NULL ); i++ ) { for (j = 0; (j < SOME_KV_NODES_COUNT) && (z > 0); j++, z--) { free(p_tmp->nodes[j].key); } p_old = p_tmp; p_tmp = p_tmp->next; if (p_old != &list.head) { free(p_old); } } goto FAIL_MEMORY; } memset(p_new, 0, sizeof(struct some_kv)); p_old->next = p_new; p_new->prev = p_old; p_old = p_new; } /* * fix bug: index is error if list.count = n * SOME_KV_NODES_COUNT(1024), * SOME_KV_NODES_COUNT = 1024, n > 0. */ if (index == 0) { index = SOME_KV_NODES_COUNT; } /* save key */ p_new->nodes[index - 1].klen = klen; p_new->nodes[index - 1].key = malloc(GET_NEED_COUNT( klen, G_PAGE_SIZE ) * G_PAGE_SIZE); memcpy(p_new->nodes[index - 1].key, p_key, klen); /* find next */ leveldb_iter_next(iter); } /* create result */ if (list.count > 0) { /* has members */ /* *2\r\n$5\r\nmykey\r\n$5\r\nmyval\r\n */ *size = strlen("*\r\n") + get_number_len(list.count) + strlen("$\r\n\r\n") * (list.count) + list.knubs + list.klens; index = GET_NEED_COUNT( *size, G_PAGE_SIZE ) * G_PAGE_SIZE; result = (char *) malloc(index); if (result == NULL ) goto FAIL_MEMORY; memset(result, 0, index); log_debug("----->>>ALL SIZE IS %d, BUFF %p : LEN IS %d\n", *size, result, index); /* split piece */ index = GET_NEED_COUNT( list.count, SOME_KV_NODES_COUNT ); p_tmp = &list.head; sprintf(result, "*%d\r\n", list.count); p_dst = result + strlen(result); for (i = 0, z = list.count; (i < index) && (p_tmp != NULL ); i++ ) { for (j = 0; (j < SOME_KV_NODES_COUNT) && (z > 0); j++, z--) { p_dst = set_bulk(p_dst, p_tmp->nodes[j].key, p_tmp->nodes[j].klen); free(p_tmp->nodes[j].key); } p_old = p_tmp; p_tmp = p_tmp->next; if (p_old != &list.head) { free(p_old); } } } else { /* no members */ *size = 0; } leveldb_iter_destroy(iter_save); return result; FAIL_ITER_PARSE: fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, (err)); leveldb_free(err); err = NULL; leveldb_iter_destroy(iter); *size = -1; return NULL ; FAIL_MEMORY: fprintf(stderr, "%s:%d: FAILED MALLOC !\n", __FILE__, __LINE__); leveldb_iter_destroy(iter); *size = -1; return NULL ; }
char *ldb_info(struct _leveldb_stuff *ldbs, int *size) { int cnt = 0; *size = 0; /* #server */ char svr[16] = "# Server:"; ++cnt; *size += strlen(svr) + get_number_len(strlen(svr)); /* tsdb version */ char vers[32] = TSDB_VERSION; ++cnt; *size += strlen(vers) + get_number_len(strlen(vers)); /* os */ char os[64] = { 0 }; struct utsname name; uname(&name); sprintf(os, "os: %s %s %s", name.sysname, name.release, name.machine); ++cnt; *size += strlen(os) + get_number_len(strlen(os)); /* pid */ char pid[32] = { 0 }; sprintf(pid, "process_id: %ld", (long) getpid()); ++cnt; *size += strlen(pid) + get_number_len(strlen(pid)); /* mode. */ char mode[32] = { 0 }; sprintf(mode, "mode: %s", LDB_READONLY_SWITCH ? "readonly" : "read/write"); ++cnt; *size += strlen(mode) + get_number_len(strlen(mode)); /* write_port */ char wport[32] = { 0 }; sprintf(wport, "write_port: %d", W_PORT); ++cnt; *size += strlen(wport) + get_number_len(strlen(wport)); /* read_port */ char rport[32] = { 0 }; sprintf(rport, "read_port: %d", R_PORT); ++cnt; *size += strlen(rport) + get_number_len(strlen(rport)); /* uptime_in_seconds */ char uptis[64] = { 0 }; time_t curtime; time(&curtime); sprintf(uptis, "uptime_in_seconds: %ld", (curtime - LDB_START_TIME)); ++cnt; *size += strlen(uptis) + get_number_len(strlen(uptis)); /* uptime_in_days */ char uptid[64] = { 0 }; sprintf(uptid, "uptime_in_days: %ld", (curtime - LDB_START_TIME) / (24 * 3600)); ++cnt; *size += strlen(uptid) + get_number_len(strlen(uptid)); /* # Keyspace. */ char keyspace[32] = "\n# Keyspace:\nTODO"; ++cnt; *size += strlen(keyspace) + get_number_len(strlen(keyspace)); /* #LeveldbStatus: */ char ldbstat[32] = "\n# Leveldbstatus:"; ++cnt; *size += strlen(ldbstat) + get_number_len(strlen(ldbstat)); /* get property. */ char *property = leveldb_property_value(ldbs->db, "leveldb.stats"); ++cnt; *size += strlen(property) + get_number_len(strlen(property)); /* create result */ *size += strlen("*\r\n") + get_number_len(cnt) + strlen("$\r\n\r\n") * cnt; int index = GET_NEED_COUNT( *size, G_PAGE_SIZE ) * G_PAGE_SIZE; char *result = (char *) malloc(index); char *ptr = NULL; sprintf(result, "*%d\r\n", cnt); /* #Server */ ptr = result + strlen(result); ptr = set_bulk(ptr, svr, strlen(svr)); ptr = set_bulk(ptr, vers, strlen(vers)); ptr = set_bulk(ptr, os, strlen(os)); ptr = set_bulk(ptr, mode, strlen(mode)); ptr = set_bulk(ptr, pid, strlen(pid)); ptr = set_bulk(ptr, wport, strlen(wport)); ptr = set_bulk(ptr, rport, strlen(rport)); ptr = set_bulk(ptr, uptis, strlen(uptis)); ptr = set_bulk(ptr, uptid, strlen(uptid)); /* #Keyspace */ ptr = set_bulk(ptr, keyspace, strlen(keyspace)); /* #Leveldbstatus */ ptr = set_bulk(ptr, ldbstat, strlen(ldbstat)); ptr = set_bulk(ptr, property, strlen(property)); leveldb_free(property); log_debug("%s\n", result); return result; }