afs_uint32
ParseVNode(XFILE * X, dump_parser * p)
{
tag_parse_info pi;
unsigned char tag;
afs_uint32 r;
prep_pi(p, &pi);
if ((r = ReadByte(X, &tag)))
return handle_return(r, X, tag, p);
if (tag != TAG_VNODE)
return handle_return(0, X, tag, p);
r = parse_vnode(X, &tag, &top_fields[2], 0, &pi, (void *)p, 0);
if (!r && tag >= 1 && tag <= 4)
r = DSERR_DONE;
return handle_return(r, X, tag, p);
}
afs_uint32
ParseDumpHeader(XFILE * X, dump_parser * p)
{
tag_parse_info pi;
unsigned char tag;
afs_uint32 r;
prep_pi(p, &pi);
if ((r = ReadByte(X, &tag)))
return handle_return(r, X, tag, p);
if (tag != TAG_DUMPHEADER)
return handle_return(0, X, tag, p);
r = parse_dumphdr(X, &tag, &top_fields[0], 0, &pi, (void *)p, 0);
if (!r && tag >= 1 && tag <= 4)
r = DSERR_DONE;
return handle_return(r, X, tag, p);
}
afs_uint32
ParseDumpFile(XFILE * X, dump_parser * p)
{
tag_parse_info pi;
unsigned char tag;
afs_uint32 r;
prep_pi(p, &pi);
r = ParseTaggedData(X, top_fields, &tag, &pi, (void *)p, 0);
return handle_return(r, X, tag, p);
}
void
match(void) {
size_t len;
Item *item, *itemend, *lexact, *lprefix, *lsubstr, *exactend, *prefixend, *substrend;
len = strlen(text);
matches = lexact = lprefix = lsubstr = itemend = exactend = prefixend = substrend = NULL;
for(item = items; item; item = item->next)
if(!fstrncmp(text, item->text, len + 1)) {
appenditem(item, &lexact, &exactend);
}
else if(!fstrncmp(text, item->text, len)) {
appenditem(item, &lprefix, &prefixend);
}
else if(fstrstr(item->text, text)) {
appenditem(item, &lsubstr, &substrend);
}
if(lexact) {
matches = lexact;
itemend = exactend;
}
if(lprefix) {
if(itemend) {
itemend->right = lprefix;
lprefix->left = itemend;
}
else
matches = lprefix;
itemend = prefixend;
}
if(lsubstr) {
if(itemend) {
itemend->right = lsubstr;
lsubstr->left = itemend;
}
else
matches = lsubstr;
}
curr = prev = next = sel = matches;
calcoffsets();
if(returnearly && !curr->right) {
handle_return(curr->text);
}
}
static int
trace_func(PyObject *obj, PyFrameObject *frame, int what, PyObject *arg)
{
if (!should_trace_module(frame->f_code->co_filename)) {
return 0;
}
switch (what) {
case PyTrace_CALL:
handle_call(frame);
break;
case PyTrace_RETURN:
handle_return(frame, arg);
break;
case PyTrace_EXCEPTION: // setprofile translates exceptions to calls
handle_exception(frame, arg);
}
return 0;
}
fdja_value *flon_execut(
const char *domain, fdja_value *tree, fdja_value *payload, fdja_value *vars)
{
execution_id = flu_sprintf("%s-transient", domain);
execution_path = NULL;
execution = fdja_v("{ exid: \"%s\", nodes: {} }", execution_id);
msgs = flu_list_malloc();
fdja_value *msg = fdja_v("{ point: execute, exid: \"%s\" }", execution_id);
fdja_set(msg, "tree", tree);
fdja_set(msg, "payload", payload);
fdja_set(msg, "vars", vars);
flu_list_add(msgs, msg);
fdja_value *terminated = NULL;
while (1)
{
fdja_value *m = flu_list_shift(msgs); if (m == NULL) break;
fdja_value *point = fdja_l(m, "point");
char p = point ? *fdja_srk(point) : 0;
if (p == 'e')
handle_execute(p, m);
else if (p == 'r') // receive
handle_return(p, m);
else if (p == 't') // terminated
{ terminated = m; break; }
//else
// simply discard
fdja_free(m);
}
unload_execution();
return terminated;
}
static void execute()
{
while (1)
{
load_msgs();
if (msgs->size < 1) break;
for (size_t i = 0; i < ROW_SIZE; ++i)
{
fdja_value *j = flu_list_shift(msgs);
if (j == NULL) break;
//fgaj_i(fdja_tod(j));
//fgaj_i(fdja_to_djan(j, 0));
//fdja_putdc(j);
fdja_value *point = fdja_l(j, "point");
char p = point ? *fdja_srk(point) : 0;
if (p == 'e')
handle_execute(p, j);
else if (p == 'r' || p == 'c') // receive or cancel
handle_return(p, j);
else if (p)
handle_event(p, j);
else
reject_or_discard_msg(p, j);
fdja_free(j);
}
}
persist();
}
char *
gettxt(const char *msg_id, const char *dflt_str)
{
struct db_cache *dbc;
struct db_list *dbl;
char msgfile[DB_NAME_LEN]; /* name of static shared library */
int msgnum; /* message number */
char pathname[PATH_MAX]; /* full pathname to message file */
int fd;
struct stat64 sb;
void *addr;
char *tokp;
size_t name_len;
char *curloc;
if ((msg_id == NULL) || (*msg_id == '\0')) {
return (handle_return(dflt_str));
}
/* parse msg_id */
if (((tokp = strchr(msg_id, ':')) == NULL) || *(tokp+1) == '\0')
return (handle_return(dflt_str));
if ((name_len = (tokp - msg_id)) >= DB_NAME_LEN)
return (handle_return(dflt_str));
if (name_len > 0) {
(void) strncpy(msgfile, msg_id, name_len);
msgfile[name_len] = '\0';
} else {
lrw_rdlock(&_rw_cur_cat);
if (cur_cat == NULL || *cur_cat == '\0') {
lrw_unlock(&_rw_cur_cat);
return (handle_return(dflt_str));
}
/*
* We know the following strcpy is safe.
*/
(void) strcpy(msgfile, cur_cat);
lrw_unlock(&_rw_cur_cat);
}
while (*++tokp) {
if (!isdigit((unsigned char)*tokp))
return (handle_return(dflt_str));
}
msgnum = atoi(msg_id + name_len + 1);
curloc = setlocale(LC_MESSAGES, NULL);
lmutex_lock(&gettxt_lock);
try_C:
dbc = db_cache;
while (dbc) {
if (strcmp(curloc, dbc->loc) == 0) {
dbl = dbc->info;
while (dbl) {
if (strcmp(msgfile, dbl->db_name) == 0) {
/* msgfile found */
lmutex_unlock(&gettxt_lock);
goto msgfile_found;
}
dbl = dbl->next;
}
/* not found */
break;
}
dbc = dbc->next;
}
if (dbc == NULL) {
/* new locale */
if ((dbc = lmalloc(sizeof (struct db_cache))) == NULL) {
lmutex_unlock(&gettxt_lock);
return (handle_return(dflt_str));
}
if ((dbc->loc = lmalloc(strlen(curloc) + 1)) == NULL) {
lfree(dbc, sizeof (struct db_cache));
lmutex_unlock(&gettxt_lock);
return (handle_return(dflt_str));
}
dbc->info = NULL;
(void) strcpy(dbc->loc, curloc);
/* connect dbc to the dbc list */
dbc->next = db_cache;
db_cache = dbc;
}
if ((dbl = lmalloc(sizeof (struct db_list))) == NULL) {
lmutex_unlock(&gettxt_lock);
return (handle_return(dflt_str));
}
if (snprintf(pathname, sizeof (pathname),
_DFLT_LOC_PATH "%s" MESSAGES "%s", dbc->loc, msgfile) >=
sizeof (pathname)) {
lfree(dbl, sizeof (struct db_list));
lmutex_unlock(&gettxt_lock);
return (handle_return(dflt_str));
}
if ((fd = open(pathname, O_RDONLY)) == -1 ||
fstat64(fd, &sb) == -1 ||
(addr = mmap(NULL, (size_t)sb.st_size, PROT_READ, MAP_SHARED,
fd, 0L)) == MAP_FAILED) {
if (fd != -1)
(void) close(fd);
lfree(dbl, sizeof (struct db_list));
if (strcmp(dbc->loc, "C") == 0) {
lmutex_unlock(&gettxt_lock);
return (handle_return(dflt_str));
}
/* Change locale to C */
curloc = (char *)loc_C;
goto try_C;
}
(void) close(fd);
/* save file name, memory address, fd and size */
(void) strcpy(dbl->db_name, msgfile);
dbl->addr = (uintptr_t)addr;
/* connect dbl to the dbc->info list */
dbl->next = dbc->info;
dbc->info = dbl;
lmutex_unlock(&gettxt_lock);
msgfile_found:
/* check if msgnum out of domain */
if (msgnum <= 0 || msgnum > *(int *)dbl->addr)
return (handle_return(dflt_str));
/* return pointer to message */
return ((char *)(dbl->addr +
*(int *)(dbl->addr + msgnum * sizeof (int))));
}
void
keypress(XKeyEvent *ev) {
char buf[32];
size_t len;
KeySym ksym;
len = strlen(text);
XLookupString(ev, buf, sizeof buf, &ksym, NULL);
if(ev->state & ControlMask) {
switch(tolower(ksym)) {
default:
return;
case XK_a:
ksym = XK_Home;
break;
case XK_b:
ksym = XK_Left;
break;
case XK_c:
ksym = XK_Escape;
break;
case XK_d:
ksym = XK_Delete;
break;
case XK_e:
ksym = XK_End;
break;
case XK_f:
ksym = XK_Right;
break;
case XK_h:
ksym = XK_BackSpace;
break;
case XK_i:
ksym = XK_Tab;
break;
case XK_j:
ksym = XK_Return;
break;
case XK_k: /* delete right */
text[cursor] = '\0';
match();
break;
case XK_n:
ksym = XK_Down;
break;
case XK_p:
ksym = XK_Up;
break;
case XK_u: /* delete left */
insert(NULL, 0 - cursor);
break;
case XK_w: /* delete word */
while(cursor > 0 && text[nextrune(-1)] == ' ')
insert(NULL, nextrune(-1) - cursor);
while(cursor > 0 && text[nextrune(-1)] != ' ')
insert(NULL, nextrune(-1) - cursor);
break;
case XK_y: /* paste selection */
XConvertSelection(dc->dpy, XA_PRIMARY, utf8, utf8, win, CurrentTime);
return;
}
}
switch(ksym) {
default:
if(!iscntrl(*buf))
insert(buf, strlen(buf));
break;
case XK_Delete:
if(cursor == len)
return;
cursor = nextrune(+1);
case XK_BackSpace:
if(cursor > 0)
insert(NULL, nextrune(-1) - cursor);
break;
case XK_End:
if(cursor < len) {
cursor = len;
break;
}
while(next) {
sel = curr = next;
calcoffsets();
}
while(sel && sel->right)
sel = sel->right;
break;
case XK_Escape:
exit(EXIT_FAILURE);
case XK_Home:
if(sel == matches) {
cursor = 0;
break;
}
sel = curr = matches;
calcoffsets();
break;
case XK_Left:
if(cursor > 0 && (!sel || !sel->left || lines > 0)) {
cursor = nextrune(-1);
break;
}
else if(lines > 0)
return;
case XK_Up:
if(sel && sel->left && (sel = sel->left)->right == curr) {
curr = prev;
calcoffsets();
}
break;
case XK_Next:
if(!next)
return;
sel = curr = next;
calcoffsets();
break;
case XK_Prior:
if(!prev)
return;
sel = curr = prev;
calcoffsets();
break;
case XK_Return:
case XK_KP_Enter:
handle_return((sel && !(ev->state & ShiftMask)) ? sel->text : text);
case XK_Right:
if(cursor < len) {
cursor = nextrune(+1);
break;
}
else if(lines > 0)
return;
case XK_Down:
if(sel && sel->right && (sel = sel->right) == next) {
curr = next;
calcoffsets();
}
break;
case XK_Tab:
if(!sel)
return;
strncpy(text, sel->text, sizeof text);
cursor = strlen(text);
match();
break;
}
drawmenu();
}
