C++ print_stack函数代码示例

void CScriptEngine::process_file_if_exists	(LPCSTR file_name, bool warn_if_not_exist)
{
	u32						string_length = xr_strlen(file_name);
	if (!warn_if_not_exist && no_file_exists(file_name,string_length))
		return;

	string256				S,S1;
	if (m_reload_modules || (*file_name && !namespace_loaded(file_name))) {
		FS.update_path		(S,"$game_scripts$",strconcat(S1,file_name,".script"));
		if (!warn_if_not_exist && !FS.exist(S)) {
#ifdef DEBUG
#	ifndef XRSE_FACTORY_EXPORTS
			if (psAI_Flags.test(aiNilObjectAccess))
#	endif
			{
				print_stack			();
				Msg					("* trying to access variable %s, which doesn't exist, or to load script %s, which doesn't exist too",file_name,S1);
				m_stack_is_ready	= true;
			}
#endif
			add_no_file		(file_name,string_length);
			return;
		}
#ifndef MASTER_GOLD
		Msg					("* loading script %s",S1);
#endif // MASTER_GOLD
		m_reload_modules	= false;
		load_file_into_namespace(S,*file_name ? file_name : "_G");
	}
}

void do_it(FILE *p,int *btm,int cap)
{
	int *top;
	int count = 0;
	top = NULL;
	int mode = read(p);
	while(mode != 0)
	{
		if(mode == 1)
		{
			if(count >= cap)
			printf("STACK OWERFOLW\n");
			else
			{
				int ins = read(p);
				top = push(top,ins,btm);
				count++;
			}
		}
		if(mode == 2)
		{
			top = pop(top,btm);
			count--;
		}
		if(mode == 3)
		peek(top);
		if(mode == 4)
		print_stack(top,btm);
		mode = read(p);
	}
}

int main()
{
	head=NULL;
	int data,choice=1;
	while(choice)
	{
		printf("\t\tMENU\n1:Push\n2:Pop\n3:Print\n0:Exit\f");
		scanf("%d",&choice);
		switch(choice)
		{
			case 1:
				printf("Enter the number : ");
				scanf("%d",&data);
				push(data);
				break;
			case 2:
				pop();
				break;
			case 3:
				print_stack(head);
				break;
			case 0:
				return 0;
			default:
				printf("Wrong Input . Please enter again.....\n");
				break;
		}
	}
	return 0;
}

static void print_stacks(void)
{
	struct key_t key = {}, next_key;
	__u64 value;
	__u32 stackid = 0, next_id;
	int fd = map_fd[0], stack_map = map_fd[1];

	sys_read_seen = sys_write_seen = false;
	while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
		bpf_map_lookup_elem(fd, &next_key, &value);
		print_stack(&next_key, value);
		bpf_map_delete_elem(fd, &next_key);
		key = next_key;
	}

	if (!sys_read_seen || !sys_write_seen) {
		printf("BUG kernel stack doesn't contain sys_read() and sys_write()\n");
		int_exit(0);
	}

	/* clear stack map */
	while (bpf_map_get_next_key(stack_map, &stackid, &next_id) == 0) {
		bpf_map_delete_elem(stack_map, &next_id);
		stackid = next_id;
	}
}

int popd(){
  print_stack(root);
  printf("\n");
  char * new_dir = stack_pop(root);
  root = root->next;
  return cd(new_dir);
}

void walk(int point, struct stack_t* stk, struct ALGraph* _alg)
{
	int idx = -1;
	struct point_t* next_point = NULL;

	struct ALGraph* alg = NULL;
	alg = (struct ALGraph*)malloc(sizeof(struct ALGraph));
	init_ALGraph(alg);
	cpy_ALGraph(alg, _alg);

	//fprintf(stdout, "\n--------------------\n");

	//print_ALGraph(alg);

	stack_push(stk, point);

	//print_stack(stk);

	/*是否全部走完*/
	if (if_walk_through(alg))
	{
		print_stack(stk);

		return;
	}
	
	idx = find_point(alg, point);

	if (-1 == idx)
	{
		fprintf(stderr, "find_point THIS CAN NOT HAPPEN!\n");
		exit(-1);
	}

	next_point = alg->point_array[idx].next;

	while (next_point != NULL)
	{
		idx = find_edge(alg, point, next_point->val);

		if (-1 == idx)
		{
			fprintf(stderr, "find_edge THIS CAN NOT HAPPEN!\n");
			exit(-1);
		}

		if (!alg->edge_array[idx].walk)
		{
			alg->edge_array[idx].walk = 1;

			walk(next_point->val, stk, alg);
			stack_pop(stk);
			alg->edge_array[idx].walk = 0;
		}

		next_point = next_point->next;
	}

	return;
}

void change_times(Time& t1, Time t2) {
    
    label_stack((uintptr_t *)&t1, "t1");
    label_stack((uintptr_t *)&t2, "t2");
    std::cout << "Before calling - IN change_times" << std::endl;
    print_stack();
    
    t1.setHour(15);
    t1.setMinute(20);
    t1.setSecond(21);
    
    t2.setMinute(50);
    
    std::cout << "after calling - IN change_times " << std::endl;
    print_stack();
    
}

	void Logger::fatal(const char* fmt, ...){
		print_stack();
		va_list vl;
		va_start(vl, fmt);
		logv(Logger::FATAL, fmt, vl);
		va_end(vl);
		abort();
	}

void print_stack(struct NODE *temp)
{
        if(temp==NULL)
                return;
        print_stack(temp->next);
        printf("%d-->",temp->data);
        return;
}

void print_trace(state_t *st) {
    fprintf(stderr, "DEBUG:\nStack:\n");
    print_stack(st);
    fprintf(stderr, "Global vars:\n");
    print_vars(st->vars, 1);
    fprintf(stderr, "Local vars:\n");
    print_vars(st->frame->vars, 0);
    fprintf(stderr, "\n");
}

static duk_ret_t test_1(duk_context *ctx) {
	printf("test_1\n");
	prep(ctx);

	/* extend with undefined */
	duk_set_top(ctx, 5);
	print_stack(ctx);

	/* chop, using a negative top value */
	duk_set_top(ctx, -3);   /* = duk_set_top(ctx, 2) */
	print_stack(ctx);

	/* to empty */
	duk_set_top(ctx, 0);
	print_stack(ctx);

	return 0;
}

void print_stack(StackNode * node){
  if(node != NULL){
    printf("%s",node->item);
    if(node->next != NULL){
      printf(" ");
      print_stack(node->next);
    }
  }
}

void print_stack(){//print the stack out
  if(isEmptyStack()){
    return;//get out if we are at the end
  }else{
    int temp = pop();//temp to hold value
    printf("%d\n", temp);//display val
    print_stack();//recur
    push(temp);//add value back when we get returned here
  }
}

void		sa(t_stack *stack, int x)
{
	int		tmp;

	tmp = stack->a_end->data;
	stack->a_end->data = stack->a_end->prev->data;
	stack->a_end->prev->data = tmp;
	++stack->n_moves;
	if (x && !stack->no_command)
		s_list_push(&stack->moves, s_list_new(ft_strdup("sa")));
	if (stack->status && x)
	{
		print_stack(&stack->a_begin, stack->number_in_a, 'a', stack->color);
		print_stack(&stack->b_begin, stack->number_in_b, 'b', stack->color);
		if (!stack->no_command)
			print_command(stack);
		write(1, "\n", 1);
	}
}

static void terminate_handler() 
{
	fprintf(stderr, "Caught unhandled exception\n");
	print_stack();
	#ifdef __GNUG__
	__gnu_cxx::__verbose_terminate_handler();
	#else
	std::abort();
	#endif
}