%%	options

copyright owner	=	Dirk Krause
copyright year	=	2014
license		=	bsd


%%	header

/**	@file	dk3madfo.h	Output functions for double values.
*/


#include <dk3conf.h>

#include <stdio.h>
#if DK3_HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#if DK3_HAVE_STDINT
#include <stdint.h>
#endif
#if DK3_HAVE_INTTYPES_H
#include <inttypes.h>
#endif
#if DK3_HAVE_LIMITS_H
#include <limits.h>
#endif
#if DK3_HAVE_MATH_H
#include <math.h>
#endif
#if DK3_HAVE_FLOAT_H
#include <float.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

/**	Print floating point value specified as string to
	output file, avoid exponential notation.
	@param	of	Output file.
	@param	buffer	Buffer containing string representation of
	value, probably in scientific notatation. The buffer content
	is modified by this function.
	The string represenation should be built using
	sprintf(buffer, "%lg", value).
*/
void
dk3ma_print_double_c8_str_no_sci(FILE *of, char *buffer);

/**	Print floating point value to output file,
	avoid exponential notation.
	@param	of	Output file.
	@param	x	Value to print.
*/
void
dk3ma_print_double_c8_no_sci(FILE *of, double x);

#ifdef __cplusplus
}
#endif



%%	module



#include "dk3ma.h"
#if DK3_HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if DK3_HAVE_UNISTD_H
#include <unistd.h>
#endif
#if DK3_HAVE_STRING_H
#include <string.h>
#endif
#if DK3_HAVE_ERRNO_H
#include <errno.h>
#endif

$!trace-include



void
dk3ma_print_double_c8_str_no_sci(FILE *of, char *buffer)
{
  char		*start;		/* Start of string. */
  char		*eptr;		/* Start of exponent substring. */
  char		*ptr;		/* Traverse string. */
  size_t	 lgt;		/* String length. */
  int		 dp;		/* Decimal dot position. */
  int		 exponent;	/* Exponent. */
  int		 i;		/* Traverse the string. */
  $? "+ dk3ma_print_double_c8_str_no_sci"
  if((of) && (buffer)) {
    eptr = NULL;
    start = buffer;
    /*
    	Print sign.
    */
    switch(*start) {
      case '-': {
        fputc('-', of);
	start++;
      } break;
      case '+': {
        start++;
      } break;
    }
    /*
    	Find exponent substring and exponent.
    */
    eptr = NULL;
    ptr = start;
    while(*ptr) {
      switch(*ptr) {
        case 'e': case 'E': {
	  eptr = ptr;
	} break;
      }
      ptr++;
    }
    if(eptr) {
      *(eptr++) = '\0';
#if VERSION_BEFORE_20140716
      if(sscanf(eptr, "%d", &exponent) != 1)
#else
      if (0 == dk3ma_i_from_c8_string(&exponent, eptr, NULL))
#endif
      {
        exponent = 0;
      }
    } else {
      exponent = 0;
    }
    /*
            Find decimal dot.
    */
    eptr = strchr(start, '.');
    if(eptr) {
      /*
              Keep dot position in dp, squeeze string.
      */
      *eptr = '\0';
      dp = (int)strlen(start);
      *eptr = '.';
      while(*eptr) {
        eptr[0] = eptr[1];
        eptr++;
      }
    } else {
      /*
              Dot position is after the string.
      */
      dp = (int)strlen(start);
    }
    /*
            Correct dot position.
    */
    dp = dp + exponent;
    /*
            Remove leading zeroes (if any).
    */
    while('0' == *start) {
      start++; dp--;
    }
    /*
            Remove trailing zeroes (if any).
    */
    eptr = NULL;
    ptr = start;
    while(*ptr) {
      if('0' == *ptr) {
        if(!(eptr)) { eptr = ptr; }
      } else {
        eptr = NULL;
      }
      ptr++;
    }
    if(eptr) { *eptr = '\0'; }
    lgt = strlen(start);
    if(0 < lgt) {
      if(dp >= (int)lgt) {
        /*
                Decimal dot is at end or after string.
        */
        fputs(start, of);
        /*
                Decimal dot is after the string.
        */
        for(i = 0; i < (dp - (int)lgt); i++) {
          fputc('0', of);
        }
      } else {
        if(dp <= 0) {
          /*
                  Decimal dot is before the string.
          */
          fputc('0', of);
          fputc('.', of);
          while(dp++ < 0) {
            fputc('0', of);
          }
          fputs(start, of);
        } else {
          /*
                  Decimal dot is in the string.
          */
          for(i = 0; i < (int)lgt; i++) {
            if(dp == i) {
              fputc('.', of);
            }
            fputc(start[i], of);
          }
        }
      }
    } else {
      /*
              No non-zero digits in string.
      */
      fputc('0', of);
    }
  } $? "- dk3ma_print_double_c8_str_no_sci"
}



void
dk3ma_print_double_c8_no_sci(FILE *of, double x)
{
  char		 buffer[64];
  $? "+ dk3ma_print_double_c8_no_sci"
  if(of) {
    sprintf(buffer, "%lg", x);
    dk3ma_print_double_c8_str_no_sci(of, buffer);
  } $? "- dk3ma_print_double_c8_no_sci"
}