//Temp stacknode to pass to pop
StackNode *dummy;
dummy = (StackNode*)malloc(sizeof(StackNode));
dummy->data = (void*)malloc(sizeof(void));
dummy->next = NULL;
dummy->prev = NULL;
dummy->type = ' ';

ZeroMemory(dummy,sizeof(StackNode));

//pas it in
Pop((void*)&dummy);

//dummy is always a bad pointer by the time I get here
if(dummy->type == 'i')
{
    printf("Contents were %d\n",*(int*)(dummy->data));
}

 // - retrieve the item from the stack
 int Pop(void **item)
 {
      /*since this is a linked list, and we are removing the head node, headnode->next becomes the new head. If headnode->next is null, then the head node is set to null, so when push is called, this is checked so a new headnode can be created. Old head points to the old headnode*/

	StackNode *oldHead = (StackNode*)malloc(sizeof(StackNode));


	if(oldHead == NULL)
		return -1;

	ZeroMemory(oldHead,sizeof(StackNode));

     /*Runtime stack is just the uper level of the linked list*/
	oldHead = runTimeStack.head;
	runTimeStack.head = runTimeStack.head->next;

	if(oldHead->type == 'i')
	{
              /* So this portion works, it is being assigned the right values from what I can see tracing it with VS 2k5*/
		(*(StackNode*)(item)).data = *(int*)(oldHead->data);
		(*(StackNode*)(item)).type = (oldHead->type);
               /*This printf does infact print what is in the head node*/
		printf("What really came off was %d\n",(*(StackNode*)(item)).data);
	}
	
	return 1;
 }

typedef struct _node 
{
	void* data;
	char type;
	struct _node* next;
	struct _node* prev;
	
} StackNode;


typedef struct _stack
{
	StackNode *head;
	unsigned int size;
} Stack;



static Stack runTimeStack;

 int Push( void *item);

 int Pop(void **item);

/* Our wrapper functions */StackNode* newStackNode() {  StackNode* result = malloc(sizeof(StackNode));  if (!result) return NULL;  result->data = NULL;  result->next = NULL;  result->prev = NULL;  result->type = ' ';  return result;}void destroyStackNode(StackNode* toDestroy) {  switch(toDestroy->type) {    case 'i':    assert(toDestroy->data);    free((int*)(toDestroy->data));    break;    case ' ':    break;    default:    assert(false);  }  free(toDestroy);}StackNode* intStackNode(int i) {  StackNode* result = newStackNode();  if (!result) return NULL;  result->data = malloc(sizeof(int));  if (!result->data) {    destroyStackNode(result);    return NULL;  }  result->type = 'i';  return result;}StackNode* copyStackNode(StackNode* other) {  switch(other->type) {    case 'i':    /* The prev and next pointers are not "intrinsic"       properties that we want to copy. */    return intStackNode(*(int*)(other->data));    case ' ':    return newStackNode();    default:    assert(false);  }}void assignStackNode(StackNode* lhs, StackNode* rhs) {  /* Behold, you can do copy-and-swap in C, although maybe you don't need to */  StackNode* other;   void* tmp;  other = copyStackNode(rhs);  tmp = lhs.data;  lhs.data = other.data;  other.data = tmp;  lhs.type = other.type;  destroyStackNode(other);}/* We can access data like this: */int* getDataIfInt(StackNode* node) {  return (node->type == 'i') ? (int*)(node->data) : NULL;}/* We'll call pop() like this: */StackNode *top;int* data;top = Pop();data = getDataIfInt();if (data) {    printf("Contents were %d\n", *data);}destroyStackNode(top);/* You could wrap that kind of logic up into a function, too, if you don't want   to burden clients with the destroyStackNode() responsibility. *//* We'll implement pop() like this: */StackNode* Pop() {  StackNode* oldHead;  oldHead = runTimeStack.head;  if (!oldHead) { return NULL; }  runTimeStack.head = runTimeStack.head->next;  /* Disconnect stuff */  runTimeStack.head->prev = NULL;  oldHead->next = NULL;  /* Do upkeep on the stack */  runTimeStack.size--;  return oldHead;}