static void
no_instance(struct tesla_class *tcp, uint32_t symbol,
const struct tesla_key *tkp)
{
char instbuf[200];
char *c = instbuf;
const char *end = instbuf + sizeof(instbuf);
SAFE_SPRINTF(c, end, "%d/%d instances\n",
tcp->tc_limit - tcp->tc_free, tcp->tc_limit);
for (uint32_t i = 0; i < tcp->tc_limit; i++) {
const struct tesla_instance *inst = tcp->tc_instances + i;
if (!tesla_instance_active(inst))
continue;
SAFE_SPRINTF(c, end, " %2u: state %d, ", i, inst->ti_state);
c = key_string(c, end, &inst->ti_key);
SAFE_SPRINTF(c, end, "\n");
}
char keybuf[20];
key_string(keybuf, keybuf + sizeof(keybuf), tkp);
SDT_PROBE(tesla, automata, fail, no_instance,
tcp, instbuf, symbol, keybuf, 0);
}
static void library_enter(MuLogger* _self, const char* path, MuLibrary* library)
{
JsonLogger* self = (JsonLogger*) _self;
elem_object_begin(self);
key_string(self, "file", path);
if (library)
{
key_string(self, "name", mu_library_name(library));
}
self->need_suites = true;
}
static void test_log(MuLogger* _self, MuLogEvent const* event)
{
JsonLogger* self = (JsonLogger*) _self;
const char* level_str = "unknown";
if (event->level > self->loglevel)
{
return;
}
if (self->need_events)
{
key_array_begin(self, "events");
self->need_events = false;
}
switch (event->level)
{
case MU_LEVEL_WARNING:
level_str = "warning"; break;
case MU_LEVEL_INFO:
level_str = "info"; break;
case MU_LEVEL_VERBOSE:
level_str = "verbose"; break;
case MU_LEVEL_DEBUG:
level_str = "debug"; break;
case MU_LEVEL_TRACE:
level_str = "trace"; break;
}
elem_object_begin(self);
key_string(self, "level", level_str);
key_string(self, "stage", mu_test_stage_to_string(event->stage));
if (event->file)
{
key_string(self, "file", event->file);
}
if (event->line)
{
key_integer(self, "line", event->line);
}
if (event->message)
{
key_string(self, "message", event->message);
}
elem_object_end(self);
}
static void
enter(MuLogger* _self)
{
JsonLogger* self = (JsonLogger*) _self;
begin_object(self);
key_string(self, "version", VERSION);
if (self->title)
{
key_string(self, "title", self->title);
}
key_array_begin(self, "libraries");
}
long _Trie::Insert (const char* key, const long value, bool return_index) {
_String key_string(key);
long ret_value = Insert (key_string, value);
if (ret_value >= 0 && return_index == false) {
return key_string.sLength;
}
return ret_value;
}
static void test_enter(MuLogger* _self, MuTest* test)
{
JsonLogger* self = (JsonLogger*) _self;
self->current_test = test;
elem_object_begin(self);
key_string(self, "name", mu_test_name(test));
self->need_events = true;
}
static void suite_enter(MuLogger* _self, const char* name)
{
JsonLogger* self = (JsonLogger*) _self;
if (self->need_suites)
{
key_array_begin(self, "suites");
self->need_suites = false;
}
elem_object_begin(self);
key_string(self, "name", name);
key_array_begin(self, "tests");
}
void
print_key(__debug const char *debug_name, const struct tesla_key *key)
{
if (!tesla_debugging(debug_name))
return;
static const size_t LEN = 15 * TESLA_KEY_SIZE + 10;
char buffer[LEN];
char *end = buffer + LEN;
__unused char *e = key_string(buffer, end, key);
assert(e < end);
print("%s", buffer);
}
HereCredentialsManager(
const uint8_t* cert_data,
uint32_t cert_data_len,
const uint8_t* privkey_data,
uint32_t privkey_data_len,
Botan::AutoSeeded_RNG& rng
)
{
std::string cert_string((char*)cert_data, cert_data_len);
std::stringstream certs_source(cert_string);
std::string key_string((char*)privkey_data, privkey_data_len);
std::stringstream key_source(key_string);
// In addition to the certificate itself, build a chain
// of certificates
Botan::DataSource_Stream certs_source_(certs_source);
Botan::DataSource_Stream key_source_(key_source);
int i = 0;
while ( not certs_source_.end_of_data() )
{
try {
certs.push_back(Botan::X509_Certificate(certs_source_));
} catch (Botan::Decoding_Error const& err)
{
if ( i == 0)
{
throw;
} else
{
break;
}
}
i ++;
}
privkey = Botan::PKCS8::load_key(
key_source_, rng
);
}
static void
engine_directfb_event_window(const DFBWindowEvent *ev)
{
DBG("===> Window Event (type=%#10x, window=%d) <===\n",
ev->type, ev->window_id);
if (ev->type & DWET_POSITION)
{
DBG("\tDWET_POSITION %d, %d\n", ev->x, ev->y);
}
if (ev->type & DWET_SIZE)
{
DBG("\tDWET_SIZE %dx%d\n", ev->w, ev->h);
evas_output_viewport_set(evas, 0, 0,
ev->w, ev->h);
evas_output_size_set(evas, ev->w, ev->h);
win_w = ev->w;
win_h = ev->h;
}
if (ev->type & DWET_CLOSE)
{
DBG("\tDWET_CLOSE\n");
engine_directfb_quit();
}
if (ev->type & DWET_DESTROYED)
{
DBG("\tDWET_DESTROYED\n");
engine_directfb_quit();
}
if (ev->type & DWET_GOTFOCUS)
{
DBG("\tDWET_GOTFOCUS\n");
}
if (ev->type & DWET_LOSTFOCUS)
{
DBG("\tDWET_LOSTFOCUS\n");
}
if (ev->type & DWET_KEYDOWN)
{
const char *k;
k = key_string(ev->key_symbol);
DBG("\tDWET_KEYDOWN key_symbol=%s\n", k);
if (k)
evas_event_feed_key_down(evas, k, k, NULL, NULL, 0, NULL);
}
if (ev->type & DWET_KEYUP)
{
const char *k;
k = key_string(ev->key_symbol);
DBG("\tDWET_KEYUP key_symbol=%s\n", k);
if (k)
evas_event_feed_key_up(evas, k, k, NULL, NULL, 0, NULL);
}
if (ev->type & DWET_BUTTONDOWN)
{
DBG("\tDWET_BUTTONDOWN pos=(%d, %d) cur_pos=(%d, %d) "
"button=%#x buttons=%#x\n",
ev->x, ev->y, ev->cx, ev->cy, ev->button, ev->buttons);
evas_event_feed_mouse_move(evas, ev->cx, ev->cy, 0, NULL);
evas_event_feed_mouse_down(evas, ev->button, EVAS_BUTTON_NONE, 0, NULL);
}
if (ev->type & DWET_BUTTONUP)
{
DBG("\tDWET_BUTTONUP pos=(%d, %d) cur_pos=(%d, %d) "
"button=%#x buttons=%#x\n",
ev->x, ev->y, ev->cx, ev->cy, ev->button, ev->buttons);
evas_event_feed_mouse_move(evas, ev->cx, ev->cy, 0, NULL);
evas_event_feed_mouse_up(evas, ev->button, EVAS_BUTTON_NONE, 0, NULL);
}
if (ev->type & DWET_MOTION)
{
DBG("\tDWET_MOTION pos=(%d, %d) cur_pos=(%d, %d) buttons=%#x\n",
ev->x, ev->y, ev->cx, ev->cy, ev->buttons);
/* Mouse Motion Compression [tm] */
_layer->GetCursorPosition( _layer, (int*)&ev->x, (int*)&ev->y );
evas_event_feed_mouse_move(evas, ev->x, ev->y, 0, NULL);
}
if (ev->type & DWET_LEAVE)
{
DBG("\tDWET_LEAVE pos=(%d, %d) cur_pos=(%d, %d)\n",
ev->x, ev->y, ev->cx, ev->cy);
evas_event_feed_mouse_out(evas, 0, NULL);
}
if (ev->type & DWET_ENTER)
{
DBG("\tDWET_ENTER pos=(%d, %d) cur_pos=(%d, %d)\n",
ev->x, ev->y, ev->cx, ev->cy);
evas_event_feed_mouse_in(evas, 0, NULL);
}
if (ev->type & DWET_WHEEL)
{
DBG("\tDWET_WHEEL step=%d\n", ev->step);
}
DBG("\n");
}
static void test_leave(MuLogger* _self,
MuTest* test, MuTestResult* summary)
{
JsonLogger* self = (JsonLogger*) _self;
if (!self->need_events)
{
key_array_end(self);
}
key_object_begin(self, "result");
key_string(self, "expected", mu_test_status_to_string(summary->expected));
key_string(self, "status", mu_test_status_to_string(summary->status));
key_string(self, "stage", mu_test_stage_to_string(summary->stage));
if (summary->reason)
{
key_string(self, "reason", summary->reason);
}
if (summary->file)
{
key_string(self, "file", summary->file);
}
if (summary->line)
{
key_integer(self, "line", summary->line);
}
key_object_end(self);
if (summary->backtrace)
{
MuBacktrace* frame;
key_array_begin(self, "backtrace");
for (frame = summary->backtrace; frame; frame = frame->up)
{
elem_object_begin(self);
if (frame->file_name)
{
key_string(self, "binary_file", frame->file_name);
}
if (frame->func_name && *frame->func_name)
{
key_string(self, "function", frame->func_name);
}
if (frame->func_addr)
{
key_begin(self, "func_addr");
print(self, "\"0x%lx\"", frame->func_addr);
key_end(self);
}
if (frame->return_addr)
{
key_begin(self, "return_addr");
print(self, "\"0x%lx\"", frame->return_addr);
key_end(self);
}
elem_object_end(self);
}
key_array_end(self);
}
elem_object_end(self);
}
static void library_fail(MuLogger* _self, const char* reason)
{
JsonLogger* self = (JsonLogger*) _self;
key_string(self, "failure", reason);
}
int main(int argc, char **argv)
{
void *rbtree;
unsigned i = 0;
int c;
char buf[256];
if (parse_args(argc, argv) == -1) {
usage();
exit(1);
}
FILE *fp = NULL;
if (!infile) {
fp = stdin;
} else {
fp = fopen(infile, "r");
if (!fp) {
fprintf(stderr, "Can't open file: %s\n", infile);
exit(1);
}
}
rbtree = rbtree_new(key_cmp, free, free);
while ((c = fgetc(fp)) != EOF) {
if (c == '\n') {
buf[i] = '\0';
rbtree_insert(rbtree, strdup(buf), strdup(buf));
memset(buf, 0, sizeof buf);
i = 0;
} else {
buf[i++] = c;
}
}
if (infile)
fclose(fp);
if (export) {
fp = fopen(export, "w");
rbtree_dump(fp, rbtree, key_string);
fclose(fp);
}
if (interactive) {
void *node;
while (1) {
i = 0;
memset(buf, 0, sizeof buf);
printf("\n> ");
while ((c = getc(stdin))) {
if (c == EOF || c == '\n')
break;
if (i >= 256) {
printf("buffer exceeded\n");
goto done;
}
buf[i++] = c;
}
if (c == EOF)
break;
if (!*buf)
continue;
buf[i] = '\0';
char *op = buf;
while (*op && *op != ' ')
op++;
if (*op) {
*op = '\0';
op++;
}
if (strncasecmp(buf, "successor", strlen("successor")) == 0) {
node = rbtree_get(rbtree, op);
if (node) {
void *n2 = rbtree_successor(rbtree, node);
if (n2)
printf("successor: %s => %s\n", key_string(rbtree_node_key(n2)),
(char *)rbtree_node_value(n2));
else
printf("no successor\n");
} else {
printf("%s (not found)\n", op);
}
} else if (strncasecmp(buf, "predecessor", strlen("predecessor")) == 0) {
node = rbtree_get(rbtree, op);
if (node) {
void *n2 = rbtree_predecessor(rbtree, node);
if (n2)
printf("predecessor: %s => %s\n", key_string(rbtree_node_key(n2)),
(char *)rbtree_node_value(n2));
else
printf("no predecessor\n");
} else {
printf("%s (not found)\n", op);
}
} else {
node = rbtree_get(rbtree, buf);
if (node)
printf("%s => %s\n", key_string(rbtree_node_key(node)),
(char *)rbtree_node_value(node));
else
printf("%s (not found)\n", buf);
}
}
}
done:
rbtree_free(rbtree);
if (infile)
free(infile);
if (export)
free(export);
return 0;
}
