C++ print_node函数代码示例

static void print_node(Node* n, std::ostream& out) {
	std::string shape=(n->player==BLACK)?"box":"circle";
	out<<"\"" << n << "\"" <<"[label=\""<<n->val/n->visits <<"\"" <<" shape="<<shape <<"];"<<std::endl;
	for (child_map::const_iterator i = n->children.begin(); i != n->children.end(); ++i) {
		print_node(i->second, out);
	}
}

	void print_node( const node &n, int indent = 0 ) {

		for( int i = 0; i < indent; ++i ) {
			std::cout << " ";
		}

		const std::string &a = n.get_annot();

		if( !a.empty() ) {
			std::cout << "[" << a << "]";
		}
		if( n.is_null() ) {
			std::cout << "null!!!\n";

		} else if( n.is_terminal() ) {
			std::cout << "term: " << n.get_terminal() << "\n";
		} else {
			std::cout << "inner:" << n.get_prod() << "\n";

			for( const node &cn : n.get_list() ) {
				print_node( cn, indent+1 );
			}

		}
	}

void
cxx_print_xnode (FILE *file, tree node, int indent)
{
  switch (TREE_CODE (node))
    {
    case BASELINK:
      print_node (file, "functions", BASELINK_FUNCTIONS (node), indent + 4);
      print_node (file, "binfo", BASELINK_BINFO (node), indent + 4);
      print_node (file, "access_binfo", BASELINK_ACCESS_BINFO (node),
		  indent + 4);
      break;
    case OVERLOAD:
      print_node (file, "function", OVL_FUNCTION (node), indent+4);
      print_node (file, "chain", TREE_CHAIN (node), indent+4);
      break;
    case TEMPLATE_PARM_INDEX:
      indent_to (file, indent + 3);
      fprintf (file, "index %d level %d orig_level %d",
	       TEMPLATE_PARM_IDX (node), TEMPLATE_PARM_LEVEL (node),
	       TEMPLATE_PARM_ORIG_LEVEL (node));
      break;
    case TEMPLATE_INFO:
      print_node (file, "template", TI_TEMPLATE (node), indent+4);
      print_node (file, "args", TI_ARGS (node), indent+4);
      if (TI_PENDING_TEMPLATE_FLAG (node))
	{
	  indent_to (file, indent + 3);
	  fprintf (file, "pending_template");
	}
      break;
    case ARGUMENT_PACK_SELECT:
      print_node (file, "pack", ARGUMENT_PACK_SELECT_FROM_PACK (node),
		  indent+4);
      indent_to (file, indent + 3);
      fprintf (file, "index %d", ARGUMENT_PACK_SELECT_INDEX (node));
      break;
    case DEFERRED_NOEXCEPT:
      print_node (file, "pattern", DEFERRED_NOEXCEPT_PATTERN (node), indent+4);
      print_node (file, "args", DEFERRED_NOEXCEPT_ARGS (node), indent+4);
      break;
    case LAMBDA_EXPR:
      cxx_print_lambda_node (file, node, indent);
      break;
    default:
      break;
    }
}

/* Prints all the Nodes in a list. */
void print_list(Node *node)
{
	if (node == NULL) 
		return;
	print_hashable(node->key);
	print_node(node);
	print_list(node->next);
}

static void free_image_node(image_node * current)
{
    print_node(current->item);
	SCI_FREE(current->item->mem);
	SCI_FREE(current->item->image_id);
	SCI_FREE(current->item);
	SCI_FREE(current);
}

void display_line_aux(t_sm_line l)
{
    if (IS_EMPTY_SM_LINE(l)) {
    } else {
	print_node(NODE_SM_LINE(l));
	display_line_aux(NEXT_SM_LINE(l));
    }
}

int cmd_parse_expr(FILE *file, const char *filename, const char *cmd)
{
    log_set_unit(basename(filename));

    lexer_init(file);
    parser_init();
    generator_init();

    struct node* node = NULL;
    symtable_t symtable = NULL;
    code_t code = NULL;

    if (strcmp(cmd, "parse_expr") == 0) {
        parser_flags_set(0);
        node = parser_parse_expr();
        print_node(node, 0, 0);
    } else if (strcmp(cmd, "parse_stmt") == 0) {
        parser_flags_set(0);
        node = parser_parse_statement();
        print_node(node, 0, 0);
    } else if (strcmp(cmd, "parse") == 0) {
        parser_flags_set(PF_RESOLVE_NAMES);
        symtable = parser_parse();
        print_symtable(symtable, 0);
    } else if (strcmp(cmd, "compile") == 0) {
        symtable = parser_parse();
        if (symtable != NULL) {
            code = generator_process(symtable);
            optimizer_optimize(code);
            generator_print_code(code);
        } else {
            print_symtable(symtable, 0);
        }
    }

    parser_free_node(node);
    symtable_destroy(symtable, 1);
    generator_free_code(code);

    generator_destroy();
    parser_destroy();
    lexer_destroy();

    log_close();
    return EXIT_SUCCESS;
}

void print_node(struct node *head)
{
	printf("%d\n", head->data);
	if (head->next != NULL)
		print_node(head->next);
	else
		return;
}

/* Print a leaf.
 */
static void *
print_leaf( JoinNode *node )
{
	if( node->type == JOIN_LEAF ) 
		print_node( node );

	return( NULL );
}

void print_finger(FILE *out, Finger *f, char *prefix, char *suffix)
{
	fprintf(out, "%sFinger:", prefix);
	print_node(out, &f->node);
	fprintf(out, " (status = %s, npings = %d, rtt = %ld/%ld) %s",
		   f->status ? "ACTIVE" : "PASSIVE", f->npings, f->rtt_avg, f->rtt_dev,
		   suffix);
}

void peg_print(struct peg_grammar *peg, FILE *out)
{
	int i;
	for ( i = 0; i < peg->max_nodes; ++i )
		if ( pn_is_type(peg, i, PEG_DEFINITION) )
			print_node(peg, i, 0, 0, out);
	fprintf(out, "\n");
}

static int print_db_tree(DB_NODE *root)
{
    if (!root)
        return 1;

    print_node(root);
    return 0;
}

int main(void)
{
	DARR *darr, *tmparr;
	struct scope tmp;
	int i;
	
	if ((darr = load_darr("db.db")) == NULL){
		printf("load db error.\n");
		if ((darr = create_darr(sizeof(struct scope))) == NULL) {
			printf("create date error.\n");
			return -1;
		}
	}
	
	for (i = 1; i <= 20; i++) {
		tmp.id = i;
		tmp.scope = 100 -i;
		snprintf(tmp.name, MAXNAME, "stu%d", i);
		if (append_darr(darr, &tmp) == -1)
			break;
	}

	i = 4;
	print_node(fetch(darr,&i,cmp_id));
#if 0
	for (i = 2; i < 13; i++)
	  delete_node(darr,&i,cmp_id);
	travel(darr,print_node);
	i = 15;
	print_node(fetch(darr,&i,cmp_id));
	travel(darr,print_node);
	travel(darr,print_node);
	i = 10;
	tmparr = fetch(darr, &i, cmp_id);
	printf("----------------------\n");
	print_node(tmparr);
	printf("----------------------\n");
	inserd_node(darr,tmparr,1);
	travel(darr,print_node);
	//save_darr(darr, "db.db");
	erase(darr);
	//printf("after travel\n");
	
#endif
	return 0;
}

/* Prints all the Nodes in a list. */
void print_list(Node *node)
{
    Node* current = node;
    while (current) {
        print_node(current);
        current = current->next;
    } 
}

// print the tree
void OBBTreeNavigator::print_tree() {
  // output file
  std::ofstream dotfile ("graph.dot");
  dotfile << "digraph graphname { " << std::endl;
  print_node(rootBox,dotfile);
  // navigate around the tree printing each node and its children
  dotfile << "} " << std::endl;
}