mprintf.c

一个通用的隐性马尔可夫C代码库 开发环境:C语言 简要说明:这是一个通用的隐性马尔可夫C代码库

    case 'f' :
    case 'e' :
    case 'E' :
    case 'g' :
    case 'G' :
      if( sizemodif == 'L' ) aux_float = va_arg(*ap, long double);
      else                   aux_float = va_arg(*ap, double);
      mprintf_conv_float( tmp, flags, minwidth, precision, sizemodif, convchar, 
			    aux_float );
      break;
    case 't': /* rel. time   */
    case 'T': /* abs. time   */
      {
	clock_diff = clock();
	if( minwidth < 0 ) minwidth = 6;
	if( precision< 0 ) precision = 2;
	if( convchar == 't' ) {
	  clock_diff = clock() - va_arg(*ap, clock_t );
	  minwidth--;
	  tmp[0] = '+';
	  res = tmp + 1;
	} 
	else {
	  res = tmp;
	}
	mprintf_conv_float( res, flags, minwidth, precision, sizemodif, 'f',  
			    clock_diff/(double)CLOCKS_PER_SEC );
	strcat( tmp, " sec" );
      }
      break;      
    case 'n' : flags = 0; minwidth = 0; break; 
    default  : leave = 1; break; 
    }
    if( leave ) break;
    
    leave = strlen( tmp );
    if( leave > maxwidth ) {
      memset( tmp, '~', maxwidth );
      tmp[maxwidth] = 0;
      leave = maxwidth;
    }
    *dlen = leave;
    res = tmp;
    break;    
    
  } /* while( 1 ) */
  /* "mprintf.c", line 350: warning: end-of-loop code not reached   */
  /* SUN cc complains, but I am not Frank N黚el.... (achim 010422 ) */
  
  /* update format and flen: */
  *flen  -= src - *format ;
  *format = src;
  return(res);
} /* mprintf_get_next */

/*----------------------------------------------------------------------------*/
static int mprintf_memcpy( char** dst, int* dpos, int* dlen, 
			   char*  src, int  slen, int  dyn ) {
  char* newdst;
  int   newlen;

  if( *dpos + slen >= *dlen ) {
    newdst = NULL;
    if( dyn ) {
      newlen = *dlen + 0x100;
      while( newlen <= *dpos + slen ) newlen += 0x100;
      newdst = realloc( *dst, newlen );
    }
    else newlen = 0;
    if( !dyn || !newdst ) {
      if( *dlen < 1 ) return(0);
      memset( *dst, '~', *dlen-1 );
      (*dst)[*dlen-1] = 0;
      *dpos = *dlen;
      return( -1 );
    }
    
    *dst  = newdst;
    *dlen = newlen;
  }
  memcpy( *dst + *dpos, src, slen );
  (*dst)[*dpos + slen] = 0;
  *dpos += slen;
  return( 0 );
} /* mprintf_memcpy */

/*============================================================================*/
char* mprintf_va( char* dst, int dlen, char* format, va_list args ) {
  va_list ap;
  int     dyn;
  int     dpos;
  char*   next;
  int     nlen;
  int     flen;
  
  if( dst && dlen ) dst[0] = 0;
  if( !format || dlen == 1 ) return( dst );
  
  
  /*****************************************************/
  
  memcpy( (void*)&ap, (void*)&args, sizeof( va_list ) );
  
  /*****************************************************/
  
  
  dyn = ( !dst || dlen <= 0 );
  if( !dst )          dlen = 0;
  else if( dlen < 0 ) dlen = -dlen;
  if( !dlen ) {
    dlen = 0x400;
    if( dst ) free( dst );
    dst = malloc( dlen );           /* no messsage here  ! */
    if( !dst ) return(NULL);
  }
  
  flen = strlen( format );
  dpos = 0;
  while( flen ) {
    if( *format == '%' ) {
      if( format[1] == '%' ) {
	next = format;
	nlen = 1;
	format += 2;
	flen   -= 2;
      }
      else {
	next = mprintf_get_next( &format, &flen, &nlen, &ap );
	if( !next ) return(dst);
      }
    }
    else {
      next = memchr( format, '%', flen );
      if( !next ) next = format + flen;
      nlen    = next - format;
      next    = format;
      format += nlen;
      flen   -= nlen;
    }
    if( mprintf_memcpy( &dst, &dpos, &dlen, next, nlen, dyn ) ) return(dst);
  }
  
  return(dst);
} /* mprintf_va */
  
/*============================================================================*/
char* mprintf( char* dst, int maxlen, char* format, ... ) { 
  va_list args;
  char*   res;
  
  va_start( args, format );
  res = mprintf_va( dst, maxlen, format, args );
  return(res);
} /* mprintf */

/*============================================================================*/
char* mprintf_va_dyn( char* dst, int maxlen, char* format, va_list args ) { 
  char* res = NULL;
  
  res = mprintf_va( dst, maxlen, format, args );
  if( !res || !dst || maxlen <= 0 ) return(res); 
  if( strlen( res ) < maxlen - 1 ) return(res);
  res = mprintf_va( NULL, 0, format, args );
  return(res);
} /* mprintf_va_dyn */


/*============================================================================*/
char* mprintf_dyn( char* dst, int maxlen, char* format, ... ) { 
  va_list args;
  char*   res;
  
  va_start( args, format );
  res = mprintf_va_dyn( dst, maxlen, format, args );
  return(res);
} /* mprintf_dyn */



/******************************************************************************/
#if defined( TEST )

#include "mes.h"
/*============================================================================*/
int mprintf_tst( void ) {
  char  dst[13];
  char* dyn = malloc( 10 );
  
  int  i;
  char* format_i[] = {
    "%12d",
    "%012d",
    "% 012d",
    "%+12d",
    "%+012d",
    "%-12d",
    "%- 12d",
    "%-+12d",
    "%12.4d",
    "%-12.4d",
    "\n",
    
    "%14u",
    "%014u",
    "%#14u",
    "%#014u",
    "%-14u",
    "%-#14u",
    "%14.4u",
    "%-14.4u",
    "\n",
    
    "%14o",
    "%014o",
    "%#14o",
    "%#014o",
    "%-14o",
    "%-#14o",
    "%14.4o",
    "%-#14.4o",
    "%-14.4o",
    "\n",
    
    "%12x",
    "%012x",
    "%#12X",
    "%#012X",
    "%-12x",
    "%-#12x",
    "%12.4x",
    "%-#12.4x",
    "%-12.4X",
    "\n",
    
    "\n"
  };
  
  char* format_c[] = {
    "%12c",
    "%012c",
    "%-12c",
    "\n"
  };

  char* format_s[] = {
    "%12s",
    "%12.5s",
    "%012s",
    "%-12s",
    "\n"
  };

  char* format_f[] = {
    "%10.2f",
    "%010.2f",
    "% 010.2f",
    "%+10.2f",
    "%+010.2f",
    "%-10.2f",
    "%- 10.2f",
    "%-+10.4f",
    "\n",
  
    "%10.2e",
    "%010.2e",
    "% 010.2e",
    "%+10.2E",
    "%+010.2E",
    "%-10.2e",
    "%- 10.2e",
    "%-+10.4e",
    "\n",

  };
  
  for( i = 0; i < sizeof(format_i)/sizeof(format_i[0]); i++ ) {
    mes_win( mprintf( dst, sizeof(dst), "%12s", format_i[i] ) );
    mes_win( "\t" );
    mes_win( mprintf( dst, sizeof(dst), format_i[i], 45 ) );
    mes_win( "\t\t" );
    mes_win( mprintf( dst, sizeof(dst), format_i[i], -45 ) );
    mes_win( "\n" );
  }
  
  for( i = 0; i < sizeof(format_c)/sizeof(format_c[0]); i++ ) {
    mes_win( mprintf( dst, sizeof(dst), "%12s", format_c[i] ) );
    mes_win( "\t" );
    mes_win( mprintf( dst, sizeof(dst), format_c[i], '*' ) );
    mes_win( "\n" );
  }
  
  for( i = 0; i < sizeof(format_s)/sizeof(format_s[0]); i++ ) {
    mes_win( mprintf( dst, sizeof(dst), "%12s", format_s[i] ) );
    mes_win( "\t" );
    mes_win( mprintf( dst, sizeof(dst), format_s[i], "zap" ) );
    mes_win( "\t\t" );
    mes_win( mprintf( dst, sizeof(dst), format_s[i], "longish" ) );
    mes_win( "\n" );
  }
  
  for( i = 0; i < sizeof(format_f)/sizeof(format_f[0]); i++ ) {
    mes_win( mprintf( dst, sizeof(dst), "%12s", format_f[i] ) );
    mes_win( "\t" );
    mes_win( mprintf( dst, sizeof(dst), format_f[i], 12.678 ) );
    mes_win( "\t\t" );
    mes_win( mprintf( dst, sizeof(dst), format_f[i], -12.678 ) );
    mes_win( "\n" );
  }
  
  dyn = mprintf_dyn( dst, sizeof(dst), " %s %s (%2T)\n", "Uhrzeit", ":" );
  mes_win( dyn );
  
  if( dyn && dyn - dst ) free( dyn );
  return(0);
} /* mprintf_tst */

#endif /* defined( TEST ) */