>    return p;
> }

>   enqueue(q, -1);
[...]
> struct myQueue* newQueue(void)
> {
>   struct myQueue* p = malloc(1 * sizeof *p);
>   if(NULL == p)
>     {
>       printf("Out of Memory\n");
>       exit(EXIT_FAILURE);
>     }

>   return p;

> void printQueue(struct myQueue* q)
> {
>   if(q)
>     {
>       struct myStruct* p = q->head;

> ======================== OUTPUT ==========================
> [arnuld@dune C]$ gcc -ansi -pedantic -Wall -Wextra Queue.c
> [arnuld@dune C]$ ./a.out
> -----------------------------------------
> Empty Queue, Adding first element
> Adding Element
> Adding Element
> Adding Element
> Adding Element
> Adding Element
> Adding Element
> title: -1
> title: 100
> title: 38
> title: 100
> title: 38
> title: 9
> title: 100
> -----------------------------------------
> Segmentation fault
> [arnuld@dune C]$

>> WANTED: Removing all elements matching a particular key from a Queue
>> WHAT I GOT: Segfault
>> WANTED: Segfaults in removeAllMatches().  I think routine/fucntion is too
>> complex to be understood. removeAllMatches(arg1, arg2) is supposed to
>> remove all elements from arg1 which match value of arg2.

> I don't get any output at all it crashes at the first printQueue() call in
> main(). The Head and Tail pointers contain crap (0xcdcdcd on a Microsoft
> system). They contain crap because newQueue() doesn't initialise them.
> Why didn't you use a debugger? That's how I found the bug.

> #include <stdio.h>
> #include <stdlib.h>

> struct myStruct
> {
>   int num;
>   struct myStruct* next;

> };

> struct myQueue
> {
>   struct myStruct* head;
>   struct myStruct* tail;

> };

> int enqueue(struct myQueue* q, int n);
> int dequeue(struct myQueue* q);

> struct myQueue* newQueue(void);
> void makeNull(struct myQueue* q);
> void removeAllMatches(struct myQueue* q, const int num);

> void printQueue(struct myQueue* q);
> void printStruct(struct myStruct* p);

> int main(void)
> {
>   struct myQueue* q = newQueue();
>   printQueue(q);

>   enqueue(q, -1);
>   enqueue(q, 100);
>   enqueue(q, 38);
>   enqueue(q, 100);
>   enqueue(q, 38);
>   enqueue(q, 9);
>   enqueue(q, 100);
>   printQueue(q);

>   removeAllMatches(q, 100);
>   printQueue(q);
>   /*  makeNull(q);
>       printQueue(q); */
>   free(q);
>   q = NULL;

>   return 0;

> }

> int enqueue(struct myQueue* q, int n)
> {
>   int ret;
>   if(NULL == q)
>     {
>       printf("Invalid Args\n");
>       ret = -1;
>     }
>   else
>     {
>       struct myStruct* p = malloc(1 * sizeof *p);
>       if(NULL == p)
>         {
>           printf("Out of memory\n");
>           exit(EXIT_FAILURE);
>         }

>       p->num = n;
>       p->next = NULL;
>       if(NULL == q->tail && NULL == q->head)
>         {
>           printf("Empty Queue, Adding first element\n");
>           q->head = q->tail = p;
>           ret = 0;
>         }
>       else if(NULL == q->tail || NULL == q->head)
>         {
>           printf("IN: %s @%d; ", __func__, __LINE__);
>           printf("There is something seriously wrong with head/tail
> assignment of your Queue\n");
>           free(p);
>           ret = 1;
>         }
>       else
>         {
>           printf("Adding Element\n");
>           q->tail->next = p;
>           q->tail = p;
>           ret = 0;
>         }
>     }

>   return ret;

> }

> int dequeue(struct myQueue* q)
> {
>   int ret = -1;
>   if(NULL == q)
>     {
>       printf("Invalid Args\n");
>       ret = -1;
>     }
>   else
>     {
>       struct myStruct* h;
>       if(NULL == q->head && NULL == q->tail)
>         {
>           printf("Queue is already empty\n");
>           ret = 0;
>         }
>       else if(NULL == q->head || NULL == q->tail)
>         {
>           printf("IN: %s @%d; ", __func__, __LINE__);
>           printf("There is something seriously wrong with head/tail
> assignment of your Queue\n");
>           ret = 1;
>         }
>       else
>         {
>           h = q->head;
>           q->head = q->head->next;
>           free(h);
>           if(NULL == q->head)
>             {
>               printf("Removing Last element left\n");
>               q->head = q->tail = NULL;
>             }
>           else
>             {
>               printf("Removing Some element\n");
>             }
>           ret = 0;
>         }
>     }

>   return ret;

> }

> /* Added many months later */
> void removeAllMatches(struct myQueue* q, const int num)
> {
>   if(NULL == q)
>     {
>       printf("Invalid Args\n");
>       return;
>     }

>   if(NULL == q->head && NULL == q->tail)
>     {
>       printf("Queue is already empty\n");
>     }
>   else if(NULL == q->head || NULL == q->tail)
>     {
>       printf("IN: %s @%d; ", __func__, __LINE__);
>       printf("There is something seriously wrong with head/tail
> assignment of your Queue\n");
>       exit(EXIT_FAILURE);
>     }
>   else
>     {
>       struct myStruct *p, *d, *h;
>       p = d = h = NULL;
>       for(h = q->head; h; h = h->next)
>         {
>           d = h;
>           if(num == d->num)
>             {
>               if(num == q->head->num )
>                 {
>                   q->head = q->head->next;
>                 }

>               if(num == q->tail->num)
>                 {
>                   q->tail = q->tail->next;
>                 }

>               if(p)
>                 {
>                   p->next = h->next;
>                 }
>               free(d);
>             }
>           else
>             {
>               p = h;
>             }
>         }

>     }

> }

> void makeNull(struct myQueue* q)
> {
>   if(q)
>     {
>       while(q->head) dequeue(q);
>     }

> }

> struct myQueue* newQueue(void)
> {
>   struct myQueue* p = malloc(1 * sizeof *p);
>   if(NULL == p)
>     {
>       printf("Out of Memory\n");
>       exit(EXIT_FAILURE);
>     }

>   return p;

> }

> void printQueue(struct myQueue* q)
> {
>   if(q)
>     {
>       struct myStruct* p = q->head;
>       for(; p; p = p->next)  printStruct(p);
>       printf("-----------------------------------------\n");
>     }

> }

> void printStruct(struct myStruct* p)
> {
>   if(p)
>     {
>       printf("title: %d\n", p->num);
>     }

> }

> ======================== OUTPUT ==========================
> [arnuld@dune C]$ gcc -ansi -pedantic -Wall -Wextra Queue.c
> [arnuld@dune C]$ ./a.out
> -----------------------------------------
> Empty Queue, Adding first element
> Adding Element
> Adding Element
> Adding Element
> Adding Element
> Adding Element
> Adding Element
> title: -1
> title: 100
> title: 38
> title: 100
> title: 38
> title: 9
> title: 100
> -----------------------------------------
> Segmentation fault
> [arnuld@dune C]$

> --
>  arnuldhttp://LispMachine.Wordpress.com

>               if(num == q->tail->num)
>                 {
>                   q->tail = q->tail->next;

>               if(p)
>                 {
>                   p->next = h->next;
>                 }
>               free(d);
>             }

>    if(NULL == q->head&&  NULL == q->tail)
>      {
>        printf("Queue is already empty\n");
>      }
>    else if(NULL == q->head || NULL == q->tail)
>      {
>        printf("IN: %s @%d; ", __func__, __LINE__);
>        printf("There is something seriously wrong with head/tail
> assignment of your Queue\n");
>        exit(EXIT_FAILURE);
>      }
>    else
>      {
>        struct myStruct *p, *d, *h;
>        p = d = h = NULL;
>        for(h = q->head; h; h = h->next)
>    {
>      d = h;
>      if(num == d->num)
>        {
>          if(num == q->head->num )
>            {
>              q->head = q->head->next;
>            }

>          if(num == q->tail->num)
>            {
>              q->tail = q->tail->next;
>            }

>          if(p)
>            {
>              p->next = h->next;
>            }
>          free(d);

>      }
> }

>>    return p;
>> }
>      Hint: What are the values of the elements in the newly-allocated
> struct?

>#include <stdio.h>
>#include <stdlib.h>

>enum { CODE_SUCC = 0, CODE_ERR = 1 };

>struct myStruct
>{
>  int num;
>  struct myStruct* next;
>};

>struct myQueue
>{
>  struct myStruct* head;
>  struct myStruct* tail;
>};

>int enqueue(struct myQueue* q, int n);
>int dequeue(struct myQueue* q);

>struct myQueue* newQueue(void);
>void makeNull(struct myQueue* q);
>void removeAllMatches(struct myQueue* q, const int num);

>void printQueue(struct myQueue* q);
>void printStruct(struct myStruct* p);
>int queue_sanity_check(struct myQueue* q);

>int main(void)
>{
>  struct myQueue* q = newQueue();
>  printQueue(q);

>  enqueue(q, -1);
>  enqueue(q, 100);
>  enqueue(q, 38);
>  enqueue(q, 100);
>  enqueue(q, 38);
>  enqueue(q, 9);
>  enqueue(q, 100);
>  printQueue(q);

>  removeAllMatches(q, 100);
>  printQueue(q);
>  /*
>  makeNull(q);
>  printQueue(q);
>  free(q);
>  q = NULL;
>  */
>  return 0;
>}

>int enqueue(struct myQueue* q, int n)
>{
>  struct myStruct* p;
>  if(CODE_ERR == queue_sanity_check(q))
>    {
>      printf("IN: %s @%d: Sanity Check failed\n", __func__, __LINE__);
>      return CODE_ERR;
>    }

>  p = malloc(1 * sizeof *p);

>  p->num = n;
>  p->next = NULL;

>  if(NULL == q->tail && NULL == q->head)
>    {
>      printf("Empty Queue, Adding first element\n");
>      q->head = q->tail = p;
>    }
>  else
>    {
>      printf("Adding Element to tail\n");
>      q->tail->next = p;
>      q->tail = p;
>    }

>  return CODE_SUCC;
>}

>int dequeue(struct myQueue* q)
>{
>  int ret = CODE_ERR;;

>  if(CODE_ERR == queue_sanity_check(q))
>    {
>      ret = CODE_ERR;

>  else
>    {
>      struct myStruct* h;
>      h = q->head;
>      q->head = q->head->next;

>      ret = CODE_SUCC;
>    }

>  return ret;
>}

>/* Added many months later */
>void removeAllMatches(struct myQueue* q, const int num)
>{
>  struct myStruct *previous, *current;
>  if(CODE_ERR == queue_sanity_check(q))
>    {
>      return;
>    }

>  previous = NULL;

>          if(num == q->tail->num)

>          if(previous)

>          free(current);
>        }
>      else
>        {
>          previous = current;

>void makeNull(struct myQueue* q)
>{

>struct myQueue* newQueue(void)
>{
>  struct myQueue* p = malloc(1 * sizeof *p);
>  if(NULL == p)
>    {
>      printf("Out of Memory\n");
>      exit(EXIT_FAILURE);
>    }

>  p->head = p->tail = NULL;

>  return p;
>}

>void printQueue(struct myQueue* q)
>{
>  if(q)
>    {
>      struct myStruct* p = q->head;
>      for(; p; p = p->next) printStruct(p);
>      printf("-----------------------------------------\n");
>    }
>}

>void printStruct(struct myStruct* p)
>{
>  if(p)
>    {
>      printf("title: %d\n", p->num);
>    }
>}

>int queue_sanity_check(struct myQueue* q)
>{
>  int ret = CODE_ERR;
>  if(NULL == q)
>    {
>      printf("Invalid Args\n");
>      ret = CODE_ERR;
>    }
>  else if(NULL == q->head && NULL == q->tail)
>    {
>      printf("Queue is already empty\n");
>      ret = CODE_SUCC;
>    }
>  else if(NULL == q->head || NULL == q->tail)

>  return ret;
>}

>================ OUTPUT =====================
>/home/arnuld/programs/C $ gcc -ansi -pedantic -Wall -Wextra Queue.c
>/home/arnuld/programs/C $ ./a.out
>-----------------------------------------
>Queue is already empty
>Empty Queue, Adding first element
>Adding Element to tail
>Adding Element to tail
>Adding Element to tail
>Adding Element to tail
>Adding Element to tail
>Adding Element to tail
>title: -1
>title: 100
>title: 38
>title: 100
>title: 38
>title: 9
>title: 100
>-----------------------------------------
>title: -1
>title: 38
>title: 38
>title: 9

> >> WANTED: Removing all elements matching a particular key from a Queue
> >> WHAT I GOT: Segfault
> >> WANTED: Segfaults in removeAllMatches().  I think routine/fucntion is too
> >> complex to be understood. removeAllMatches(arg1, arg2) is supposed to
> >> remove all elements from arg1 which match value of arg2.

> > I don't get any output at all it crashes at the first printQueue() call in
> > main(). The Head and Tail pointers contain crap (0xcdcdcd on a Microsoft
> > system). They contain crap because newQueue() doesn't initialise them.

> > Why didn't you use a debugger? That's how I found the bug.

> Mine just prints forever on printQueue(). Looking at newQueue() instantly
> reveals the problem.

> >> WANTED: Removing all elements matching a particular key from a Queue
> >> WHAT I GOT: Segfault
> >> WANTED: Segfaults in removeAllMatches().  I think routine/fucntion is too
> >> complex to be understood. removeAllMatches(arg1, arg2) is supposed to
> >> remove all elements from arg1 which match value of arg2.

> > I don't get any output at all it crashes at the first printQueue() call in
> > main(). The Head and Tail pointers contain crap (0xcdcdcd on a Microsoft
> > system). They contain crap because newQueue() doesn't initialise them.

> > Why didn't you use a debugger? That's how I found the bug.

> Mine just prints forever on printQueue(). Looking at newQueue() instantly
> reveals the problem.

>>  for(current = q->head; current; current = current->next)
> Whenever you free current in the loop, the third expression above
> invokes undefined behavior on the next iteration.
>>        {
>>          if(num == current->num)

> During iteration 1, this is false.

> During iteration 2, this is true.

> During iteration 3, this is false.

> During iteration 4, this is true.
> ..SNIP... LOTS OF CODE

>> Mine just prints forever on printQueue(). Looking at newQueue() instantly
>> reveals the problem.

> and main()

>> No need for any debugger. And what exactly did it say anyway?

> well the program has Undefined Behaviour so the question isn't really
> meaningful. Visual C++ gives:-

> "Unhandled exception at 0x00411cc9 in quick.exe: 0xC0000005: Access
> violation reading location 0xcdcdcdcd."

> The debugger shows it crashed in printStruct() and p has an insane value.

> > well the program has Undefined Behaviour so the question isn't really
> > meaningful. Visual C++ gives:-

> > "Unhandled exception at 0x00411cc9 in quick.exe: 0xC0000005: Access
> > violation reading location 0xcdcdcdcd."

> > The debugger shows it crashed in printStruct() and p has an insane value.

> As I said, when I tried it under one compiler, it just looped forever
> p;rinting the same sequence of 3 or 4 values, so p (ie. q->head) presumably
> had a sensible enough value.

> Debuggers have their uses but are probably overkill for an obvious logic
> error within the first dozen lines of execution!

>>> On 09 May 2012 05:43:02 GMT, arnuld <sunr...@invalid.address> wrote:

>> ret is already initialized to CODE_ERR.

> I know. I learned from someone here that assignment at initialization of
> a variable is always a good idea. I see it solves problems for me (in
> case of int types)

>> You already know q->head is NULL.

> yeah. So, instead of s->head = s->tail = NULL, I could have used s->tail
> = s->head. It was just a matter of style for me.

>>  for(current = q->head; current; current = current->next)
> Whenever you free current in the loop, the third expression above
> invokes undefined behavior on the next iteration.

>>> On 09 May 2012 05:43:02 GMT, arnuld <sunr...@invalid.address> wrote:

>>>  p = malloc(1 * sizeof *p);

>> What is the point of multiplying by 1?

>Because it makes me remember that malloc() takes number of elements. It
>sounds strange but I do forget to add number of elements most of the
>times.

>>>  for(current = q->head; current; current = current->next)

>> Whenever you free current in the loop, the third expression above
>> invokes undefined behavior on the next iteration.

>It did not. Now I know why. After free(current), current may be pointing
>to garbage. That's why the practice of setting the pointer to NULL after
>free() was created.

>Oddly, code worked fine all the time on my machine producing correct
>results for 8 hours. Just now it Segfaulted.

>It is broke, Still trying to figure out how to write it correctly.

>> I think the if test should be on the pointers, not on num:
>>      if (current = q->tail)

>aah... pointers do compare equal like int
>(you meant current == q->tail)

>I understood my mistake. Like I said, I did the analysis after reading
>your analysis I can see that head/tail pointing at wrong places, so I
>should make a check for that too ?  No, unlike earlier now I think those
>checks will not save these programming errors I am making. I better set
>pointers right rather than spending my typing-energy to avoid/find errors.

>> This demonstrates you don't use q->tail so why bother maintaining it?

>q->tail to add, q->head to remove. Thats the purpose.

> True.  I apologize for my excess sarcasm.

> --
> Remove del for email

> > Better to remember something true.  malloc takes number of bytes.
> > calloc takes number of elements and number of bytes per element but
> > involves extra overhead which is not needed here.

> calloc() = malloc() + memset() ??

> #include <stdio.h>
> #include <stdlib.h>

> struct myStruct
> {
>   int num;
>   struct myStruct* next;
> };

> struct myQueue
> {
>   struct myStruct* head;
>   struct myStruct* tail;
> };

> int enqueue(struct myQueue* q, int n);
> int dequeue(struct myQueue* q);

> struct myQueue* newQueue(void);
> void makeNull(struct myQueue* q);
> void removeAllMatches(struct myQueue* q, const int num);

> void printQueue(struct myQueue* q);
> void printStruct(struct myStruct* p);

> int main(void)
> {
>   struct myQueue* q = newQueue();
>   printQueue(q);

>   enqueue(q, -1);
>   enqueue(q, 100);
>   enqueue(q, 38);
>   enqueue(q, 100);
>   enqueue(q, 38);
>   enqueue(q, 9);
>   enqueue(q, 100);
>   printQueue(q);

>   removeAllMatches(q, 100);
>   printQueue(q);
>   /*  makeNull(q);
>       printQueue(q); */
>   free(q);
>   q = NULL;

>   return 0;
> }

> int enqueue(struct myQueue* q, int n)
> {
>   int ret;
>   if(NULL == q)
>     {
>       printf("Invalid Args\n");
>       ret = -1;
>     }
>   else
>     {
>       struct myStruct* p = malloc(1 * sizeof *p);
>       if(NULL == p)
>    {
>      printf("Out of memory\n");
>      exit(EXIT_FAILURE);
>    }

>       p->num = n;
>       p->next = NULL;
>       if(NULL == q->tail && NULL == q->head)
>    {
>      printf("Empty Queue, Adding first element\n");
>      q->head = q->tail = p;
>      ret = 0;
>    }
>       else if(NULL == q->tail || NULL == q->head)
>    {
>      printf("IN: %s @%d; ", __func__, __LINE__);
>      printf("There is something seriously wrong with head/tail
> assignment of your Queue\n");
>      free(p);
>      ret = 1;
>    }
>       else
>    {
>      printf("Adding Element\n");
>      q->tail->next = p;
>      q->tail = p;
>      ret = 0;
>    }
>     }

>   return ret;
> }

> int dequeue(struct myQueue* q)
> {
>   int ret = -1;
>   if(NULL == q)
>     {
>       printf("Invalid Args\n");
>       ret = -1;
>     }
>   else
>     {
>       struct myStruct* h;
>       if(NULL == q->head && NULL == q->tail)
>    {
>      printf("Queue is already empty\n");
>      ret = 0;
>    }
>       else if(NULL == q->head || NULL == q->tail)
>    {
>      printf("IN: %s @%d; ", __func__, __LINE__);
>      printf("There is something seriously wrong with head/tail
> assignment of your Queue\n");
>      ret = 1;
>    }
>       else
>    {
>      h = q->head;
>      q->head = q->head->next;
>      free(h);
>      if(NULL == q->head)
>        {
>          printf("Removing Last element left\n");
>          q->head = q->tail = NULL;
>        }
>      else
>        {
>          printf("Removing Some element\n");
>        }
>      ret = 0;
>    }
>     }

>   return ret;
> }

> /* Added many months later */
> void removeAllMatches(struct myQueue* q, const int num)
> {
>   if(NULL == q)
>     {
>       printf("Invalid Args\n");
>       return;
>     }

>   if(NULL == q->head && NULL == q->tail)
>     {
>       printf("Queue is already empty\n");
>     }
>   else if(NULL == q->head || NULL == q->tail)
>     {
>       printf("IN: %s @%d; ", __func__, __LINE__);
>       printf("There is something seriously wrong with head/tail
> assignment of your Queue\n");
>       exit(EXIT_FAILURE);
>     }
>   else
>     {
>       struct myStruct *p, *d, *h;
>       p = d = h = NULL;
>       for(h = q->head; h; h = h->next)
>    {
>      d = h;
>      if(num == d->num)
>        {
>          if(num == q->head->num )
>            {
>              q->head = q->head->next;
>            }

>          if(num == q->tail->num)
>            {
>              q->tail = q->tail->next;
>            }

>          if(p)
>            {
>              p->next = h->next;
>            }
>          free(d);
>        }
>      else
>        {
>          p = h;
>        }
>    }

>     }
> }

> void makeNull(struct myQueue* q)
> {
>   if(q)
>     {
>       while(q->head) dequeue(q);
>     }
> }

> struct myQueue* newQueue(void)
> {
>   struct myQueue* p = malloc(1 * sizeof *p);
>   if(NULL == p)
>     {
>       printf("Out of Memory\n");
>       exit(EXIT_FAILURE);
>     }

>   return p;
> }

> void printQueue(struct myQueue* q)
> {
>   if(q)
>     {
>       struct myStruct* p = q->head;
>       for(; p; p = p->next)  printStruct(p);
>       printf("-----------------------------------------\n");
>     }
> }

> void printStruct(struct myStruct* p)
> {
>   if(p)
>     {
>       printf("title: %d\n", p->num);
>     }
> }

> ======================== OUTPUT ==========================
> [arnuld@dune C]$ gcc -ansi -pedantic -Wall -Wextra Queue.c
> [arnuld@dune C]$ ./a.out
> -----------------------------------------
> Empty Queue, Adding first element
> Adding Element
> Adding Element
> Adding Element
> Adding Element
> Adding Element
> Adding Element
> title: -1
> title: 100
> title: 38
> title: 100
> title: 38
> title: 9
> title: 100
> -----------------------------------------
> Segmentation fault
> [arnuld@dune C]$

> --
>  arnuld
> http://LispMachine.Wordpress.com

>calloc() = malloc() + memset() ??

> As long as malloc doesn't fail,

>> As long as malloc doesn't fail,

>And a*b doesn't overflow,

>>     calloc(a,b) = memset(malloc(a*b),0,a*b)

>> Barry Schwarz <schwa...@dqel.com> wrote:

>>> As long as malloc doesn't fail,

>> And a*b doesn't overflow,

>>>     calloc(a,b) = memset(malloc(a*b),0,a*b)

> Unsigned arithmetic cannot overflow.

> Given the wording in 7.20.3.1, where the allocated space constitutes a
> single array, I have no idea what happens when the arithmetic product
> a*b exceeds the value of SIZE_MAX. ...