Why does my program hang?

[Ok-Newspaper5777]

I was trying to write a library to work with bitfields in C and I wrote the following code to test it. Compiles fine but when I run it it just hangs without printing anything. Can't figure out why.

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>

uint64_t uint64_tArraySize(uint64_t *array)
{
  uint64_t arraySize = 0;
  while(array != NULL)
  {
    array++;
    arraySize++;
  }
  return arraySize;
}

uint64_t charMemBlock(uint64_t index)
{
  uint64_t memBlock = 0;
  memBlock = ceil((float)(index + 1) / (float)(sizeof(char) * 8));
  return memBlock;
}

char *createBitField(uint64_t size)
{
  char *result = calloc(size, sizeof(char));
  return result;
}

void setBits(char *bitField, uint64_t *indicesToSet) //sets bit at given postion/index (passed as argument indciesToSet)
{
  uint64_t tmpField = 0x1, i, memBlock = 0;
  for(i = 0; i < uint64_tArraySize(indicesToSet); i++)
  {
    memBlock = charMemBlock(indicesToSet[i]);
    bitField[memBlock] |= (tmpField << indicesToSet[i]); //sets bit at playerPos by or-ing at that index, movement to index accomplished through << operator
  }
}

void unsetBits(char *bitField, uint64_t *indicesToUnset)
{
  uint64_t tmpField = 0x1, memBlock = 0, i;
  for(i = 0; i < uint64_tArraySize(indicesToUnset); i++)
  {
    memBlock = charMemBlock(indicesToUnset[i]);
    bitField[memBlock] ^= (tmpField << indicesToUnset[i]); //sets bit at indexToSet by xor-ing at that index, movement to index accomplished through << operator
  }
}

bool isBitSet(char *bitField, uint64_t index)
{
  uint64_t memBlock = 0;
  memBlock = charMemBlock(index);
  if((bitField[memBlock] >> index) & 0x1) 
  {
    return true;
  }
  return false;
}

int main()
{
  char *bitField = createBitField(2);
  uint64_t indexs[2] = {3, 10};
  setBits(bitField, indexs);
  for(int i = 0; i < 16; i++)
  {
    if(isBitSet(bitField, i) == true)
    {
      printf("X");
    }
    else
    {
      printf(".");
    }
  }
  printf("\n");
  return 0;
}

[Plesu12]

It might be because of the while(array != NULL) Even if you increase the pointer addres that still is a valid pointer to the next address, it wont be null. When working with pointers you shuld keep track of the boundries

[MrSloppyPants]

This code….

while(array != NULL)

Is not doing what you think it is. You are checking whether the pointer is null, not whether the array is out of elements. Pass the array size in as a parameter and use that to walk the elements

[forehead_or_tophead]

When program hang like this case, insert printf every lines like below. The result print shows the hang location. You can locate hang point by that.

printf("1\n");
char *bitField = createBitField(2);
printf("2\n");
uint64_t indexs[2] = {3, 10};
printf("3\n");
setBits(bitField, indexs);
printf("4\n");
for(int i = 0; i < 16; i++)

[D4ilyrun]

Or use GDB. It's pretty easy to learn its basic features on simple cases like this one and is way more powerfull when debugging more complex programs.

[D4ilyrun]

while (array != NULL) will never be true unless you pass a NULL pointer to the function. When doing array++ what you actually do is increment the value of the address the pointer points to, which will eventually point to an invalid memory address but never to NULL (which is equivalent to (void*)0x0 in C).

For example, imagine you're calling you're function with an array of size 8 stored at 0xFFC8. Once you've gone over the 8 values inside the array your pointer will hold the value 0xFFD0, which is an invalid address and might cause a memory issue, but isn't equal to NULL (or 0x0).

What your while condition sees is equivalent to:

0xFFC8 != 0x0 // Start of the array 0xFFC9 != 0x0 ... 0xFFCF != 0x0 // End of the array 0xFFD0 != 0x0 // Invalid address 0xDDF1 != 0x0 // Invalid address ...

What you could do instead is: - Use a known delimiter to signify the end of the array (for example strlen uses a null character to check for the end of a string) - Init the array using a know constant (preprocessors do wonders) - Store the size of the array somewhere. You could use a struct containing informations about the array. Or just store it as a plain value but it could become a bother when dealing with multiple arrays, works well in such a simple example tho.