basic implementation of the queue in C

I practice data structures in C and have implemented a queue based on its description, as below. Please review my code:

#understand 
#understand 

struct QueueNode {
int data;
struct QueueNode * nextNode;
};

struct Queue {
struct QueueNode * priorNode;
struct QueueNode * lastNode;
};

struct Queue * initQueue () {
struct queue * queue = malloc (sizeof (struct queue)); // only one is needed
if (! waiting queue) {
fprintf (stderr, "memory error");
output (1);
}
queue -> priorNode = NULL;
queue-> lastNode = NULL;
back in queue;
}

void queue (waiting queue struct * queue, num int) {
struct QueueNode * queuenode = malloc (sizeof (struct QueueNode));
if (! queuenode) {
fprintf (stderr, "memory error");
output (1);
}
queuenode-> data = num;
queuenode-> nextNode = NULL;

if (! queue-> priorNode) {
queue-> priorNode = queuenode;
}

if (queue-> lastNode) {
struct QueueNode * temp = queue-> lastNode;
queue-> lastNode = queuenode;
temp-> nextNode = queue-> lastNode;
} other {
queue-> lastNode = queuenode;
}
}

struct QueueNode dequeue (struct Queue * queue) {
if (! queue-> priorNode) {
fprintf (stderr, "The queue is empty.  n");
struct QueueNode nullnode = {0, NULL};
returns nullnode;
}
struct QueueNode prior = * queue-> priorNode;
free (file-> priorNode);
if (prior.nextNode) {
queue -> priorNode = prior.nextNode;
} other {
queue -> priorNode = NULL;
}
back before;
}

void peekQueue (waiting queue * queue) {
printf (""% d  "is the current leading element of the queue  n", file-> priorNode-> data);
}

void listQueue (waiting queue struct * queue) {
struct QueueNode * qn = queue -> priorNode;

printf ("the elements in the left (oldest) row on the right (the oldest) are:  n");
while (qn) {
if (! qn-> nextNode) {
printf ("% d", qn-> data);
Pause;
}
other{
printf ("% d -", qn-> data);
qn = qn-> nextNode;
}
}
printf (" n");
}

void closeQueue (waiting queue struct * queue) {

struct QueueNode * next = NULL;
while (queue-> priorNode) {
next = queue-> priorNode-> nextNode;
free (file-> priorNode);
if (next!) pause;
queue-> priorNode = next;
}

free (queue);
}

int main () {
struct Queue * queue = initQueue ();

queuing waiting (queue, 15);
queuing (queue, 4);
queuing waiting (queue, 8);
queuing (queue, 13);
queuing (queue, 7);

listQueue (queue);

peekQueue (queue)

struct node QueueNode;

node = exit of the queue;
printf (""% d  "is out of the queue  n", node.data);
node = exit of the queue;
printf (""% d  "is out of the queue  n", node.data);
node = exit of the queue;
printf (""% d  "is out of the queue  n", node.data);
node = exit of the queue;
printf (""% d  "is out of the queue  n", node.data);
node = exit of the queue;
printf (""% d  "is out of the queue  n", node.data);
node = exit of the queue;
printf (""% d  "is out of the queue  n", node.data);

closeQueue (queue)
returns 0;
}

I did not know what to do in my dequeue function when the queue was empty. I do not want the 0 to be returned as this would be confusing for the user.