How to eliminate leading zeros in a number?

void hmi_gfx_mgr_decode_bit_format(UINT16 bit_format,
  void * bit_format_ref,
  HMI_CHAR concat_string[],
  void * text_data_vp)
{
  UINT16 Size;
  UINT16 final_size = 0;
  UINT16 len;
  UINT8 replace_char = 0;
  UINT32 *temp;
  UINT32 *temp3;
  UINT16 radix = 0;
  HMI_CHAR static_string[MAX_TEXT_LENGTH] = {0};
  HMI_CHAR DNV[9] = {0};
  UINT8 *stat = (UINT8 *)bit_format_ref;
  UINT8 *dynamic_string = (UINT8 *)text_data_vp;
  UINT16 array_index = HMI_STRLEN(concat_string);
if(bit_format == 0x02)
{
 temp3 = (UINT32 *)&bit_format_ref;
  Size = *temp3 & 0x0F;
  final_size = Size;
  temp = (UINT32 *)&text_data_vp;
  for(len = 0; len < Size; len++)
  {
  if(array_index < (MAX_TEXT_LENGTH - 1))
  {
  replace_char = (HMI_CHAR) ((*temp % 10) + 48);
  *temp = *temp/10;
  DNV[radix++] = replace_char;
  }
  else
  {
  break;
  }
  }

  Size  = *temp3 & 0xF0;
  Size  = Size >> 4;
  final_size = final_size + Size;
  temp = (UINT32 *)&text_data_vp;
  if(Size > 0)
  {
  if(array_index < (MAX_TEXT_LENGTH - 1))
  {
  DNV[radix++] = '.';
  final_size++;
  }

  for(len = 0; len < Size; len++)
  {
  if(array_index < (MAX_TEXT_LENGTH - 1))
  {
  replace_char = (HMI_CHAR) ((*temp % 10) + 48);
  *temp = *temp/10;
#ifdef LEADING_ZEROS_REQUIRED
  DNV[radix++] = replace_char;
#else
  if(len > 0)
  {
  if(replace_char != '0')
  {
  DNV[radix++] = replace_char;
  }
  }
  else if(len == 0)
  {
  DNV[radix++] = replace_char;
  }
#endif
  }
  else
  {
  break;
  }
  }
  }

  for(len = final_size; len >= 0; len--)
  {
  concat_string[array_index++] = DNV[len];
  if(len == 0)
  break;
  }
  }

To be precise i mean to say that before starting the application itself i will get to know whether i require leading zero's or not. So now if i require leading zero's i will define the macro if not i won't define based on this condition i want some code to implement this logic. What i meant about the dynamic data is, i will be getting dynamic data from application side to the code which i wrote where i should be able to eliminate leading zero's based on the macro which i will be define based on my requirement.

Of course i am finally putting them in the character array as i require that in the text format. To avoid your confusion please see the next post what i have already done.

Let us put it this way. Do you need more than one version of your program (more than one exe file), each that works differently based on the macro's parameters, or do you need one version of your program that works differently based on something that occurs during execution?

The C and C++ compilers have something called the preprocessor. The preprocessor processes the #include statements, the #define (macro) statements and all the statements that begin with a "#". The preprocessor replaces those statements with other code. After all the preprocessor statements are gone, then the compiler processes the source code. So all the source code beginning with "#" that the main compiler sees (after the preprocessor), including the macros, are gone. The macros do not exist in the source code that the main compiler sees. It is impossible to use a macro during execution.

So please read again what Vulpes said.

Whatever it is that you are trying to say, "Application will send a number" and "if the macro is defined" sound inconsistent with the way that macros work.

Also note that leading zeros apply only to a number after conversion to text. The binary representation of a number will always have the same number of leading zeros. That is not entirely true if we consider 32-bit and 64-bit to be different but I hope you understand the point I am trying to make. The point I am making is that Vulpes suggests "a C library function such as sprintf to format numbers" because leading zeros is relevant to formatting numbers. The sprintf function and functions such as it use a format string and you can use one of multiple format strings depending on some condition.

No Vulpes it looks like you mistook what i meant. Application will send a number to me at run time, so then if the macro is defined i should not eliminate leading zero's and if not defined i should keep the zero's as it is.