std::ostream& print_assignment(const ast::Assignment& assignment) {
print_indent();
stream << assignment.identifier << " := ";
node(*assignment.value);
stream << ";\n";
return stream;
}
static void xml_print_tree_internal(GNode *node, gpointer data){
NODE_DATA *node_data;
node_data = (NODE_DATA *)(node->data);
if(node_data->name){
print_indent(node_data->depth);
printf("%s", node_data->name);
if(node_data->attr != NULL){
GList *list;
NODE_ATTR *attr;
list = g_list_first(node_data->attr);
while(list){
attr = (NODE_ATTR *)(list->data);
g_print(" %s=%s", attr->name, attr->value);
list = g_list_next(list);
}
}
g_print("\n");
if(G_NODE_IS_LEAF(node)){
print_indent2(node_data->depth);
if(node_data->content != NULL){
printf(">%s<\n", node_data->content);
} else {
printf("NULL\n");
}
} else {
g_node_children_foreach(node, G_TRAVERSE_ALL, (GNodeForeachFunc)xml_print_tree_internal, (gpointer)NULL);
}
} else {
g_node_children_foreach(node, G_TRAVERSE_ALL, (GNodeForeachFunc)xml_print_tree_internal, (gpointer)NULL);
}
}
std::ostream& print_return(const ast::Return& retrn) {
print_indent();
stream << "return ";
node(*retrn.value);
stream << ";\n";
return stream;
}
void terminal_callback(struct gzl_parse_state *parse_state,
struct gzl_terminal *terminal)
{
struct gzl_buffer *buffer = (struct gzl_buffer*)parse_state->user_data;
struct gzlparse_state *user_state = (struct gzlparse_state*)buffer->user_data;
struct gzl_parse_stack_frame *frame = DYNARRAY_GET_TOP(parse_state->parse_stack);
assert(frame->frame_type == GZL_FRAME_TYPE_RTN);
struct gzl_rtn_frame *rtn_frame = &frame->f.rtn_frame;
print_newline(user_state, false);
print_indent(user_state);
char *terminal_name = get_json_escaped_string(terminal->name, 0);
int start = terminal->offset.byte - buffer->buf_offset;
assert(start >= 0);
assert(start+terminal->len <= buffer->buf_len);
char *terminal_text = get_json_escaped_string(buffer->buf+
(terminal->offset.byte - buffer->buf_offset),
terminal->len);
char *slotname = get_json_escaped_string(rtn_frame->rtn_transition->slotname, 0);
printf("{\"terminal\": %s, \"slotname\": %s, \"slotnum\": %d, \"byte_offset\": %zu, "
"\"line\": %zu, \"column\": %zu, \"len\": %zu, \"text\": %s}",
terminal_name, slotname, rtn_frame->rtn_transition->slotnum,
terminal->offset.byte, terminal->offset.line, terminal->offset.column,
terminal->len, terminal_text);
free(terminal_name);
free(terminal_text);
free(slotname);
}
void start_rule_callback(struct gzl_parse_state *parse_state)
{
struct gzl_buffer *buffer = (struct gzl_buffer*)parse_state->user_data;
struct gzlparse_state *user_state = (struct gzlparse_state*)buffer->user_data;
struct gzl_parse_stack_frame *frame = DYNARRAY_GET_TOP(parse_state->parse_stack);
assert(frame->frame_type == GZL_FRAME_TYPE_RTN);
struct gzl_rtn_frame *rtn_frame = &frame->f.rtn_frame;
print_newline(user_state, false);
print_indent(user_state);
char *rule = get_json_escaped_string(rtn_frame->rtn->name, 0);
printf("{\"rule\":%s, \"start\": %zu, \"line\": %zu, \"column\": %zu, ",
rule, frame->start_offset.byte,
frame->start_offset.line, frame->start_offset.column);
free(rule);
if(parse_state->parse_stack_len > 1)
{
frame--;
struct gzl_rtn_frame *prev_rtn_frame = &frame->f.rtn_frame;
char *slotname = get_json_escaped_string(prev_rtn_frame->rtn_transition->slotname, 0);
printf("\"slotname\":%s, \"slotnum\":%d, ",
slotname, prev_rtn_frame->rtn_transition->slotnum);
free(slotname);
}
printf("\"children\": [");
RESIZE_DYNARRAY(user_state->first_child, user_state->first_child_len+1);
*DYNARRAY_GET_TOP(user_state->first_child) = true;
}
void r3_tree_dump(node * n, int level) {
if ( n->combined_pattern ) {
printf(" regexp:%s", n->combined_pattern);
}
printf(" endpoint:%d", n->endpoint);
if (n->data) {
printf(" data:%p", n->data);
}
printf("\n");
for ( int i = 0 ; i < n->edge_len ; i++ ) {
edge * e = n->edges[i];
print_indent(level);
printf(" |-\"%s\"", e->pattern);
if (e->has_slug) {
printf(" slug:");
printf("%s", compile_slug(e->pattern, e->pattern_len) );
}
if ( e->child ) {
r3_tree_dump( e->child, level + 1);
}
printf("\n");
}
}
void
print_atr_bytes(int indent, struct card_state *cst) {
size_t i;
const char *t0_byte_names[] = { "TS", "T0", "TB1", "TC1", NULL };
const char *t1_byte_names[] = { "TS", "T0", "TB1", "TC1", "TD1", "TD2", "TA3", "TB3", "TCK", NULL };
const char **byte_names = NULL;
const char *atr = cst->atr;
size_t atr_len = cst->atr_len;
# define BYTE_NAME_FMT "%3s"
switch(cst->proto) {
case SCARD_PROTOCOL_T0:
byte_names = t0_byte_names;
break;
case SCARD_PROTOCOL_T1:
byte_names = t1_byte_names;
break;
default:
return;
}
for (i = 0; i < atr_len && byte_names[i] != NULL; ++i) {
print_indent(indent);
printf(BYTE_NAME_FMT " = 0x%02x\n", byte_names[i], (unsigned char) atr[i]);
}
}
static void print_return_stmt(int indent, struct stmt *s)
{
print_indent(indent);
printf("RETURN\n");
if (s->ret)
print_expr_r(indent+1, s->ret);
}
static void print_for_stmt(int indent, struct stmt *s)
{
print_indent(indent);
printf("FOR\n");
print_expr_r(indent+1, s->forloop.cond);
print_block_stmt(indent+1, s->forloop.block->block);
}
static void print_assign_stmt(int indent, struct stmt *s)
{
print_indent(indent);
printf("ASSIGN STMT\n");
print_expr_r(indent+1, s->assign.ident);
print_expr_r(indent+1, s->assign.rhs);
}
void enter_block(const std::string &msg, const bool indent)
{
if (inhibit_profiling_counters)
{
return;
}
block_names.emplace_back(msg);
timespec t;
clock_gettime(CLOCK_REALTIME, &t);
enter_times[msg] = t;
if (inhibit_profiling_info)
{
return;
}
#pragma omp critical
{
op_profiling_enter(msg);
print_indent();
printf("(enter) %-35s\t[0s]\t(%0.4fs from start)\n",
msg.c_str(), nsec_diff(t, start_time) * 1e-9);
fflush(stdout);
if (indent)
{
++indentation;
}
}
}
void print_funcall(struct funcall *f, int indent)
{
print_indent(indent);
int fun_id = get_funcall_name(f);
switch (fun_id)
{
case 1: /* 1 is ecrire */
print_write_fun(f);
break;
case 2: /* 2 is allouer */
print_alloc_fun(f);
break;
case 3:
print_read_function(f);
break;
case 4:
print_free_fun(f);
break;
default:
printf("%s(", f->fun_ident);
print_arglist(f->args);
printf(");\n");
}
}
void enter_block(const std::string &msg, const bool indent)
{
if (inhibit_profiling_counters)
{
return;
}
block_names.emplace_back(msg);
long long t = get_nsec_time();
enter_times[msg] = t;
if (inhibit_profiling_info)
{
return;
}
#ifdef MULTICORE
#pragma omp critical
#endif
{
op_profiling_enter(msg);
print_indent();
printf("(enter) %-35s\t[0s]\t(%0.4fs from start)\n",
msg.c_str(), (t - start_time) * 1e-9);
fflush(stdout);
if (indent)
{
++indentation;
}
}
}
static
void dump_application_name_descriptor(struct tssp_descriptor *desc, int depth, void *param)
{
int i;
int ret;
struct tssp_dr_application_name app_name;
uint8_t *value;
if (desc == NULL)
return;
ret = tssp_dr_application_name_parse(&app_name, desc);
if (ret != TSSP_STATUS_OK)
return;
for (i = 0; i < app_name.count; i++) {
value = app_name.lang[i].name;
print_indent(depth);
/* skip character table, see Annex A of A038 */
if (value[0] < 0x20) {
printf("char_table(0x%02x), ", value[0]);
value++;
}
printf("lang_code(0x%06x), value(%s)\n",
app_name.lang[i].code, value);
}
}
static void print_on_its_own_line(int indent, const char* msg,
bool newline = true) {
if (newline) printf("\n");
printf("%6c", ' ');
print_indent(indent);
printf("%s", msg);
}
void CLG_(print_eventset)(int s, EventSet* es)
{
int i, j;
UInt mask;
EventGroup* eg;
if (s<0) {
s = -s;
print_indent(s);
}
if (!es) {
VG_(printf)("(EventSet not set)\n");
return;
}
VG_(printf)("EventSet %d (%d groups, size %d):",
es->mask, es->count, es->size);
if (es->count == 0) {
VG_(printf)("-\n");
return;
}
for(i=0, mask=1; i<MAX_EVENTGROUP_COUNT; i++, mask=mask<<1) {
if ((es->mask & mask)==0) continue;
eg = CLG_(get_event_group)(i);
if (!eg) continue;
VG_(printf)(" (%d: %s", i, eg->name[0]);
for(j=1; j<eg->size; j++)
VG_(printf)(" %s", eg->name[j]);
VG_(printf)(")");
}
VG_(printf)("\n");
}
/* Print the bottom of the C file */
void print_tail ()
{
/* Blank line */
print_indent ();
fprintf (bfout, "\n");
if (dump_core)
{
print_indent ();
fprintf (bfout, "dump_core (%s, %s);\n", bfstr_buffer, bfstr_bsize);
}
print_indent ();
fprintf (bfout, "exit (EXIT_SUCCESS);\n");
fprintf (bfout, "}\n");
}
void Rule::print(int indent) const {
print_indent(indent);
printf("RULE (");
for(const auto & selector : m_selectors) {
selector.print();
printf(",");
}
print_indent(indent);
printf(") {\n");
for(const auto & p : m_properties) {
print_indent(indent+1);
p.print();
}
print_indent(indent);
printf("}\n");
}
void CLG_(print_bbcc)(int s, BBCC* bbcc, Bool jumpaddr)
{
BB* bb;
if (s<0) {
s = -s;
print_indent(s);
}
if (!bbcc) {
VG_(printf)("BBCC 0x0\n");
return;
}
bb = bbcc->bb;
CLG_ASSERT(bb!=0);
#if 0
if (jumpaddr)
VG_(printf)("%s +%p=%p, ",
bb->obj->name + bb->obj->last_slash_pos,
bb->jmp_offset, bb_jmpaddr(bb));
else
#endif
VG_(printf)("%s +%p=%p, ",
bb->obj->name + bb->obj->last_slash_pos,
bb->offset, bb_addr(bb));
CLG_(print_cxt)(s+8, bbcc->cxt, bbcc->rec_index);
}
void CLG_(print_eventset)(int s, EventSet* es)
{
int i;
if (s<0) {
s = -s;
print_indent(s);
}
if (!es) {
VG_(printf)("(EventSet not set)\n");
return;
}
VG_(printf)("%5s (Size/Cap %d/%d): ",
es->name, es->size, es->capacity);
if (es->size == 0)
VG_(printf)("-");
else {
for(i=0; i< es->size; i++) {
if (i>0) {
VG_(printf)(" ");
if (es->e[i-1].nextTop == i)
VG_(printf)("| ");
}
VG_(printf)(es->e[i].type->name);
}
}
VG_(printf)("\n");
}
static void print_ruletree_object_recurse(int indent, const char *name, ruletree_object_offset_t obj_offs)
{
ruletree_object_hdr_t *hdr;
hdr = offset_to_ruletree_object_ptr(obj_offs, 0/*any type is ok*/);
if (hdr) {
switch (hdr->rtree_obj_type) {
case SB2_RULETREE_OBJECT_TYPE_CATALOG:
dump_catalog(obj_offs, name, indent);
break;
case SB2_RULETREE_OBJECT_TYPE_OBJECTLIST:
if (name) {
print_indent(indent);
printf("'%s'\n", name);
}
dump_objectlist(obj_offs, indent+1);
break;
case SB2_RULETREE_OBJECT_TYPE_BINTREE:
dump_bintree(obj_offs, indent, 1, NULL, NULL);
break;
default:
/* ignore it. */
break;
}
} /* else ignore it. */
}
static void print_time( char *name, time_t time)
{
print_indent();
printf("%s: ",name);
showtime("time",time);
printf("\n");
}
static void print_expr_r(int indent, struct expr *e)
{
print_indent(indent);
switch (e->type) {
case EXPR_NUM:
printf("NUMBER: %f\n", e->num);
break;
case EXPR_BIN:
printf("BINARY: %c\n", tokchars[e->bin.tok]);
print_expr_r(indent+1, e->bin.lhs);
print_expr_r(indent+1, e->bin.rhs);
break;
case EXPR_IDENT:
printf("IDENT: ");
fwrite(e->ident.beg, 1, e->ident.len, stdout);
printf("\n");
break;
case EXPR_CALL:
printf("CALL: ");
fwrite(e->call.ident->ident.beg, 1, e->call.ident->ident.len, stdout);
printf("\n");
print_call_args(indent+1, e->call.args);
break;
}
}
static
void dump_descriptor(struct tssp_descriptor *desc, int depth)
{
int i;
const struct desc_entry *entry = NULL;
if (desc == NULL)
return;
for (i = 0; i < (sizeof(desc_table)/sizeof(*desc_table)); i++) {
if (desc->tag == desc_table[i].tag) {
entry = &desc_table[i];
break;
}
}
print_indent(depth);
if (entry) {
printf("%s: tag(0x%02x), length(%d)\n", entry->name, desc->tag, desc->length);
entry->func(desc, depth + 1, entry->param);
} else {
printf("tag(0x%02x), length(%d)\n", desc->tag, desc->length);
}
}
int
swf_argb_print(swf_argb_t *color, int indent_depth) {
print_indent(indent_depth);
printf("(A)RGB=(%02x)#%02x%02x%02x\n",
color->alpha, color->red, color->green, color->blue);
return 0;
}
void CLG_(print_bbcc_cost)(int s, BBCC* bbcc)
{
BB* bb;
Int i, cjmpNo;
ULong ecounter;
if (s<0) {
s = -s;
print_indent(s);
}
if (!bbcc) {
VG_(printf)("BBCC 0x0\n");
return;
}
bb = bbcc->bb;
CLG_ASSERT(bb!=0);
CLG_(print_bbcc)(s, bbcc);
ecounter = bbcc->ecounter_sum;
print_indent(s+2);
VG_(printf)("ECounter: sum %llu ", ecounter);
for(i=0; i<bb->cjmp_count; i++) {
VG_(printf)("[%d]=%llu ",
bb->jmp[i].instr, bbcc->jmp[i].ecounter);
}
VG_(printf)("\n");
cjmpNo = 0;
for(i=0; i<bb->instr_count; i++) {
InstrInfo* ii = &(bb->instr[i]);
print_indent(s+2);
VG_(printf)("[%2d] IOff %2d ecnt %3llu ",
i, ii->instr_offset, ecounter);
CLG_(print_cost)(s+5, ii->eventset, bbcc->cost + ii->cost_offset);
/* update execution counter */
if (cjmpNo < bb->cjmp_count)
if (bb->jmp[cjmpNo].instr == i) {
ecounter -= bbcc->jmp[cjmpNo].ecounter;
cjmpNo++;
}
}
}
void sdp_packet(const struct l2cap_frame *frame)
{
uint8_t pdu;
uint16_t tid, plen;
struct l2cap_frame sdp_frame;
struct tid_data *tid_info;
const struct sdp_data *sdp_data = NULL;
const char *pdu_color, *pdu_str;
int i;
l2cap_frame_pull(&sdp_frame, frame, 0);
if (!l2cap_frame_get_u8(&sdp_frame, &pdu) ||
!l2cap_frame_get_be16(&sdp_frame, &tid) ||
!l2cap_frame_get_be16(&sdp_frame, &plen)) {
print_text(COLOR_ERROR, "frame too short");
packet_hexdump(frame->data, frame->size);
return;
}
if (sdp_frame.size != plen) {
print_text(COLOR_ERROR, "invalid frame size");
packet_hexdump(sdp_frame.data, sdp_frame.size);
return;
}
for (i = 0; sdp_table[i].str; i++) {
if (sdp_table[i].pdu == pdu) {
sdp_data = &sdp_table[i];
break;
}
}
if (sdp_data) {
if (sdp_data->func) {
if (frame->in)
pdu_color = COLOR_MAGENTA;
else
pdu_color = COLOR_BLUE;
} else
pdu_color = COLOR_WHITE_BG;
pdu_str = sdp_data->str;
} else {
pdu_color = COLOR_WHITE_BG;
pdu_str = "Unknown";
}
print_indent(6, pdu_color, "SDP: ", pdu_str, COLOR_OFF,
" (0x%2.2x) tid %d len %d", pdu, tid, plen);
tid_info = get_tid(tid, frame->chan);
if (!sdp_data || !sdp_data->func || !tid_info) {
packet_hexdump(sdp_frame.data, sdp_frame.size);
return;
}
sdp_data->func(&sdp_frame, tid_info);
}
static
void dump_application_usage_descriptor(struct tssp_descriptor *desc, int depth, void *param)
{
if (desc->length == 1) {
print_indent(depth);
printf("usage_type(0x%02x)\n", *desc->data);
}
}
void operator()(
Iterator const& first
, Iterator const& last
, Context const& context
, State state
, std::string const& rule_name) const
{
int static indent = 0;
switch (state)
{
case pre_parse:
print_indent(indent++);
BOOST_SPIRIT_DEBUG_OUT
<< '<' << rule_name << '>'
<< std::endl;
print_some("try", indent, first, last);
break;
case successful_parse:
print_some("success", indent, first, last);
print_indent(indent);
BOOST_SPIRIT_DEBUG_OUT
<< "<attributes>"
<< context.attributes
<< "</attributes>";
if (!fusion::empty(context.locals))
BOOST_SPIRIT_DEBUG_OUT
<< "<locals>"
<< context.locals
<< "</locals>";
BOOST_SPIRIT_DEBUG_OUT << std::endl;
print_indent(--indent);
BOOST_SPIRIT_DEBUG_OUT
<< "</" << rule_name << '>'
<< std::endl;
break;
case failed_parse:
print_indent(indent);
BOOST_SPIRIT_DEBUG_OUT << "<fail/>" << std::endl;
print_indent(--indent);
BOOST_SPIRIT_DEBUG_OUT
<< "</" << rule_name << '>'
<< std::endl;
break;
}
}
static
void dump_stream_identifier_descriptor(struct tssp_descriptor *desc, int depth, void *param)
{
if (desc->length == 1) {
print_indent(depth);
printf("component_tag(0x%02x)\n", *desc->data);
}
}
