static __uint PMC_API _on_drop_groups(PCRTK_PACKET packet)
{
__uint count, i, ret=0;
RTK_CURSOR hNode, hGroup;
PGROUP_KEY pgk;
TAG_NAME name;
count = packet->data_size / sizeof(GROUP_KEY);
if(packet->data_size % sizeof(GROUP_KEY)){
return 0;
}
if( !lock_rtdb(true, 100) ){
return 0;
}
hNode = HNODE_LOCAL_MACHINE;
for(i=0, pgk=(PGROUP_KEY)packet->data; i<count; i++, pgk++){
name.sname.group = *pgk;
hGroup = open_group(hNode, pgk);
if(hGroup){
cursor_delete(hGroup);
ret++;
}
}
unlock_rtdb();
return ret;
}
// Deletes a symtable
void symtable_delete(struct symtable *table)
{
int i;
struct list *list = NULL;
struct cursor *c = NULL;
struct symtable_entry *entry = NULL;
if(!table)
return;
for(i = 0; i < SYMTABLE_SIZE; i++)
{
list = table->entries[i];
for(c = cursor_new_front(list); cursor_valid(c); cursor_next(c))
{
entry = cursor_get(c);
free(entry->name);
function_delete(entry->data);
free(entry);
}
list_delete(list);
cursor_delete(c);
}
free(table);
}
/*** map
* Mapping functional form. Accepts a single function argument. Input to the
* form should always be in the form of a list, and the return value will be
* the result of applying the argument function to each element in the list.
*
* map{ f } : < x, y, z > = < f : x, f : y, f : z >
*/
struct value *map(struct list *args, struct value *in)
{
struct value *out = NULL;
struct function *f = list_get(args, 0);
struct list *l = NULL;
struct cursor *c;
// First ensure valid input
if(args->count != 1 || in->type != SEQ_VAL)
{
value_delete(in);
return value_new();
}
// Otherwise create an output list by applying f to each element of in
out = value_new();
out->type = SEQ_VAL;
out->data.seq_val = list_new();
l = in->data.seq_val;
for(c = cursor_new_front(l); cursor_valid(c); cursor_next(c))
list_push_back(out->data.seq_val,
function_exec(f, value_copy(cursor_get(c))));
value_delete(in);
cursor_delete(c);
return out;
}
/* remove all references from a given identifier */
retvalue references_remove(const char *neededby) {
struct cursor *cursor;
retvalue result, r;
const char *found_to, *found_by;
size_t datalen, l;
r = table_newglobalcursor(rdb_references, &cursor);
if (!RET_IS_OK(r))
return r;
l = strlen(neededby);
result = RET_NOTHING;
while (cursor_nexttempdata(rdb_references, cursor,
&found_to, &found_by, &datalen)) {
if (datalen >= l && strncmp(found_by, neededby, l) == 0 &&
(found_by[l] == '\0' || found_by[l] == ' ')) {
if (verbose > 8)
fprintf(stderr,
"Removing reference to '%s' by '%s'\n",
found_to, neededby);
r = cursor_delete(rdb_references, cursor,
found_to, NULL);
RET_UPDATE(result, r);
if (RET_IS_OK(r)) {
r = pool_dereferenced(found_to);
RET_ENDUPDATE(result, r);
}
}
}
r = cursor_close(rdb_references, cursor);
RET_ENDUPDATE(result, r);
return result;
}
__uint PMC_API _on_drop_groups(PCRTK_PACKET packet)
{
__uint count, i, ret=0;
RTK_CURSOR hNode, hGroup;
PGROUP_KEY pgk;
TAG_NAME name;
NODE_KEY nk;
count = packet->data_size / sizeof(GROUP_KEY);
if(packet->data_size % sizeof(GROUP_KEY)){
return 0;
}
if( !lock_rtdb(true, 100) ){
return 0;
}
host_to_node(&packet->src.host, &nk);
name.node = nk;
hNode = open_node(&nk);
if(hNode){
for(i=0, pgk=(PGROUP_KEY)packet->data; i<count; i++, pgk++){
name.sname.group = *pgk;
hGroup = open_group(hNode, pgk);
if(hGroup){
cursor_delete(hGroup);
rtk_queue_event(PT_DropGroup, &name, &packet->src);
ret++;
}
}
close_handle(hNode);
}
unlock_rtdb();
return ret;
}
// Deletes every function in a list
void clear_function_list(struct list *args)
{
struct cursor *c = NULL;
for(c = cursor_new_front(args); cursor_valid(c); cursor_next(c))
if(cursor_get(c))
function_delete(cursor_get(c));
list_delete(args);
cursor_delete(c);
}
RTDB_API void PMC_API uninit_rtdb(void)
{
lock_rtdb(__true, INFINITE);
RTK_CURSOR hNode;
close_handle(g_hLocalNode);
g_hLocalNode = 0;
hNode = open_first_node();
while( !cursor_is_end(hNode) ){
cursor_delete(hNode);
hNode = open_first_node();
}
close_handle(hNode);
unlock_rtdb();
}
/*** construct
* Sequence construction. Feeds its input to each of its argument functions,
* and generate a sequence where each element is the output of one of the
* argument functions.
*
* construct{ f, g } : x = < f : x, g : x >
*/
struct value *construct(struct list *args, struct value *in)
{
struct value *out = value_new();
struct cursor *c = NULL;
out->type = SEQ_VAL;
out->data.seq_val = list_new();
for(c = cursor_new_front(args); cursor_valid(c); cursor_next(c))
{
list_push_back(out->data.seq_val,
function_exec(cursor_get(c), value_copy(in)));
}
value_delete(in);
cursor_delete(c);
return out;
}
/* Like target_removepackage, but delete the package record by cursor */
retvalue package_remove_by_cursor(struct package_cursor *tc, struct logger *logger, struct trackingdata *trackingdata) {
struct target * const target = tc->target;
struct package *old = &tc->current;
struct strlist files;
retvalue result, r;
assert (target != NULL && target->packages != NULL);
assert (target == old->target);
if (logger != NULL) {
(void)package_getversion(old);
}
r = old->target->getfilekeys(old->control, &files);
if (RET_WAS_ERROR(r)) {
return r;
}
if (trackingdata != NULL) {
(void)package_getsource(old);
}
if (verbose > 0)
printf("removing '%s' from '%s'...\n",
old->name, old->target->identifier);
result = cursor_delete(target->packages, tc->cursor, old->name, NULL);
if (RET_IS_OK(result)) {
old->target->wasmodified = true;
if (trackingdata != NULL && old->source != NULL
&& old->sourceversion != NULL) {
r = trackingdata_remove(trackingdata,
old->source, old->sourceversion, &files);
RET_UPDATE(result, r);
}
if (trackingdata == NULL)
old->target->staletracking = true;
if (logger != NULL)
logger_log(logger, old->target, old->name,
NULL, old->version,
NULL, old->control,
NULL, &files,
NULL, NULL);
r = references_delete(old->target->identifier, &files, NULL);
RET_UPDATE(result, r);
}
strlist_done(&files);
return result;
}
/*** compose
* Function composition. Feeds its input to the last function in its argument
* list, then feeds that function's output to the second-to-last, and so on,
* eventually returning the output of the last function in the list as the
* combined function's output.
*
* compose{ f, g } : x = f : (g : x)
*/
struct value *compose(struct list *args, struct value *in)
{
struct value *current = in;
struct value *last = in;
struct function *f = NULL;
struct cursor *c = NULL;
// Stepping backwards through the list of arguments and feeding
// input to successive functions, deleting intermediate values
for(c = cursor_new_back(args); cursor_valid(c); cursor_prev(c))
{
f = cursor_get(c);
last = current;
current = function_exec(f, current);
}
cursor_delete(c);
return current;
}
PROXY_API __bool PMC_API discover_nodes_ex(
__uint timeout,
__uint * count,
__bool bDiscardOld
)
{
__uint i;
if(count){
*count = 0;
}
CDiscoverNodes *eye = new CDiscoverNodes(timeout);
if(!eye){
return __false;
}
if(!eye->WaitResult()){
return __false;
}
if(bDiscardOld){
// clear database
if( !lock_rtdb(__true, timeout) ){
return __false;
}
RTK_CURSOR cursor;
cursor = open_first_node();
while(cursor){
cursor_delete(cursor);
cursor = open_first_node();
}
for(i=0; i<eye->c_nodes; i++){
cursor = create_node(&eye->nodes[i], 0);
close_handle(cursor);
}
unlock_rtdb();
}
if(count){
*count = eye->c_nodes;
}
return __true;
}
retvalue tracking_remove(trackingdb t, const char *sourcename, const char *version) {
retvalue result, r;
struct cursor *cursor;
const char *data;
size_t datalen;
char *id;
struct trackedpackage *pkg SETBUTNOTUSED(= NULL);
r = table_newpairedcursor(t->table, sourcename, version, &cursor,
&data, &datalen);
if (!RET_IS_OK(r))
return r;
id = calc_trackreferee(t->codename, sourcename, version);
if (FAILEDTOALLOC(id)) {
(void)cursor_close(t->table, cursor);
return RET_ERROR_OOM;
}
result = parse_data(sourcename, version, data, datalen, &pkg);
if (RET_IS_OK(r)) {
assert (pkg != NULL);
r = references_delete(id, &pkg->filekeys, NULL);
RET_UPDATE(result, r);
trackedpackage_free(pkg);
} else {
RET_UPDATE(result, r);
fprintf(stderr,
"Could not parse data, removing all references blindly...\n");
r = references_remove(id);
RET_UPDATE(result, r);
}
free(id);
r = cursor_delete(t->table, cursor, sourcename, version);
if (RET_IS_OK(r))
fprintf(stderr, "Removed %s_%s from %s.\n",
sourcename, version, t->codename);
RET_UPDATE(result, r);
r = cursor_close(t->table, cursor);
RET_ENDUPDATE(result, r);
return result;
}
static retvalue tracking_saveatcursor(trackingdb t, struct cursor *cursor, struct trackedpackage *pkg) {
if (pkg->flags.deleted) {
/* delete if delete is requested
* (all unreferencing has to be done before) */
return cursor_delete(t->table, cursor,
pkg->sourcename, pkg->sourceversion);
} else {
char *newdata;
size_t newdatalen;
retvalue r;
r = gen_data(pkg, &newdata, &newdatalen);
if (RET_IS_OK(r)) {
r = cursor_replace(t->table, cursor,
newdata, newdatalen);
free(newdata);
}
return r;
}
}
void PMC_API _on_drop_tags(PCRTK_PACKET packet)
{
__uint count, i;
PTAG_NAME name;
count = packet->data_size / sizeof(TAG_NAME);
if(packet->data_size % sizeof(TAG_NAME)){
return;
}
if( !lock_rtdb(true, 100) ){
return;
}
for(i=0, name=(PTAG_NAME)packet->data; i<count; i++, name++){
RTK_CURSOR hTag;
hTag = open_tag_f(name);
if(hTag){
cursor_delete(hTag);
}
rtk_queue_event(PT_DropTag, name, &packet->src);
}
unlock_rtdb();
}
// Retrieves an entry from the table
struct function *symtable_find(struct symtable *table, char *name)
{
struct list *list = table->entries[hash(name) % table->size];
struct symtable_entry *entry = NULL;
struct cursor *c = NULL;
for(c = cursor_new_front(list); cursor_valid(c); cursor_next(c))
{
entry = cursor_get(c);
if(!entry)
break;
if(!strcmp(entry->name, name))
{
cursor_delete(c);
return entry->data;
}
}
return NULL;
}
static void PMC_API _on_drop_tags(PCRTK_PACKET packet)
{
__uint count, i;
PTAG_NAME name;
RTK_CURSOR hNode;
count = packet->data_size / sizeof(TAG_NAME);
if(packet->data_size % sizeof(TAG_NAME)){
return;
}
if( !lock_rtdb(true, 100) ){
return;
}
hNode = HNODE_LOCAL_MACHINE;
for(i=0, name=(PTAG_NAME)packet->data; i<count; i++, name++){
RTK_CURSOR hTag;
hTag = open_tag(hNode, &name->sname);
if(hTag){
cursor_delete(hTag);
}
}
unlock_rtdb();
}
/* Free any object in a handlenode */
void object_free(struct handlenode *n) {
#ifdef DEBUG_KEYS
num_handles--;
#endif
#ifdef DEBUG_MEMORY
printf("Enter object free of handle 0x%08X, type %d\n",n->id,n->type &
PG_TYPEMASK);
#endif
if (!(n->type & HFLAG_NFREE)) {
switch (n->type & PG_TYPEMASK) {
case PG_TYPE_BITMAP:
VID(bitmap_free) ((hwrbitmap)n->obj);
break;
case PG_TYPE_WIDGET:
widget_remove((struct widget *)n->obj);
break;
case PG_TYPE_THEME:
theme_remove((struct pgmemtheme *)n->obj);
break;
case PG_TYPE_DRIVER:
unload_inlib((struct inlib *)n->obj);
break;
case PG_TYPE_WT:
wt_free((struct pgmemwt *)n->obj);
break;
case PG_TYPE_INFILTER:
infilter_delete((struct infilter *)n->obj);
break;
case PG_TYPE_CURSOR:
cursor_delete((struct cursor *)n->obj);
break;
case PG_TYPE_PGSTRING:
pgstring_delete((struct pgstring *)n->obj);
break;
case PG_TYPE_FONTDESC:
font_descriptor_destroy((struct font_descriptor *)n->obj);
break;
/* Object types that are memory-managed independently of their handles */
case PG_TYPE_DIVTREE:
case PG_TYPE_PARAGRAPH:
break;
default:
g_free(n->obj);
}
}
#ifdef DEBUG_MEMORY
printf("Leave object free of handle 0x%08X, type %d\n",n->id,n->type &
PG_TYPEMASK);
#endif
}
void cursor_shutdown(void) {
while (cursor_list)
cursor_delete(cursor_list);
}
void read_line() {
char buffer[STRING_SIZE];
struct listnode *node;
struct listroot *root;
int len, cnt, match;
gtd->input_buf[gtd->input_len] = 0;
len = read(0, buffer, 1);
buffer[len] = 0;
if (HAS_BIT(gtd->ses->flags, SES_FLAG_CONVERTMETA)
|| HAS_BIT(gtd->flags, TINTIN_FLAG_CONVERTMETACHAR)) {
convert_meta(buffer, >d->macro_buf[strlen(gtd->macro_buf)]);
} else {
strcat(gtd->macro_buf, buffer);
}
if (!HAS_BIT(gtd->ses->flags, SES_FLAG_CONVERTMETA)) {
match = 0;
root = gtd->ses->list[LIST_MACRO];
for (root->update = 0; root->update < root->used; root->update++) {
node = root->list[root->update];
if (!strcmp(gtd->macro_buf, node->pr)) {
script_driver(gtd->ses, LIST_MACRO, node->right);
gtd->macro_buf[0] = 0;
return;
} else if (!strncmp(gtd->macro_buf, node->pr, strlen(gtd->macro_buf))) {
match = 1;
}
}
for (cnt = 0; *cursor_table[cnt].fun != NULL; cnt++) {
if (!strcmp(gtd->macro_buf, cursor_table[cnt].code)) {
cursor_table[cnt].fun("");
gtd->macro_buf[0] = 0;
return;
} else if (!strncmp(gtd->macro_buf, cursor_table[cnt].code, strlen(gtd->macro_buf))) {
match = 1;
}
}
if (match) {
return;
}
}
if (gtd->macro_buf[0] == ESCAPE) {
strcpy(buffer, gtd->macro_buf);
convert_meta(buffer, gtd->macro_buf);
}
for (cnt = 0; gtd->macro_buf[cnt]; cnt++) {
switch (gtd->macro_buf[cnt]) {
case 10:
cursor_enter("");
break;
default:
if (HAS_BIT(gtd->flags, TINTIN_FLAG_INSERTINPUT)
&& gtd->input_len != gtd->input_cur) {
if (!HAS_BIT(gtd->ses->flags, SES_FLAG_UTF8)
|| (gtd->macro_buf[cnt] & 192) != 128) {
cursor_delete("");
}
}
ins_sprintf(>d->input_buf[gtd->input_cur], "%c", gtd->macro_buf[cnt]);
gtd->input_len++;
gtd->input_cur++;
if (!HAS_BIT(gtd->ses->flags, SES_FLAG_UTF8)
|| (gtd->macro_buf[cnt] & 192) != 128) {
gtd->input_pos++;
}
if (gtd->input_len != gtd->input_cur) {
if (HAS_BIT(gtd->ses->flags, SES_FLAG_UTF8)
&& (gtd->macro_buf[cnt] & 192) == 128) {
input_printf("%c", gtd->macro_buf[cnt]);
} else {
input_printf("\033[1@%c", gtd->macro_buf[cnt]);
}
} else {
input_printf("%c", gtd->macro_buf[cnt]);
}
gtd->macro_buf[0] = 0;
gtd->input_tmp[0] = 0;
gtd->input_buf[gtd->input_len] = 0;
cursor_check_line_modified("");
DEL_BIT(gtd->flags, TINTIN_FLAG_HISTORYBROWSE);
kill_list(gtd->ses->list[LIST_TABCYCLE]);
if (HAS_BIT(gtd->flags, TINTIN_FLAG_HISTORYSEARCH)) {
cursor_history_find("");
}
break;
}
}
}
