mprintf.c

General Hidden Markov Model Library 一个通用的隐马尔科夫模型的C代码库

        res = tmp;
        break;
      }
    }

    /* scan size modifier : */
    if (strchr ("hlL", *src))
      sizemodif = *src++;
    if (!*src)
      break;

    /* scan conversion letter */
    if (!strchr ("diuoxXfeEgGcspntTb", *src))
      break;
    convchar = *src++;

    if (maxwidth < 0 || maxwidth >= MPRINTF_TMP_LEN)
      maxwidth = MPRINTF_TMP_LEN - 1;
    if (minwidth > maxwidth)
      minwidth = maxwidth;
    leave = 0;
    switch (convchar) {
    case 'c':
    case 'd':
    case 'i':
    case 'u':
    case 'o':
    case 'x':
    case 'X':
    case 'b':
      mprintf_conv_int (tmp, flags, minwidth, precision, convchar,
                        va_arg (AP_POINTER, int));
      break;
#if 0                           /* makes only trouble */
    case 'p':
      mprintf_conv_int (tmp, flags, minwidth, precision, 'X',
                        (int) (va_arg (AP_POINTER, char *)));
      break;
#endif /* 0 */
    case 's':
      if (precision < 0 || precision > maxwidth)
        precision = maxwidth;
      mprintf_conv_str (tmp, flags, minwidth, precision,
                        va_arg (AP_POINTER, char *));
      maxwidth = MPRINTF_TMP_LEN - 1;
      break;
    case 'f':
    case 'e':
    case 'E':
    case 'g':
    case 'G':
      if (sizemodif == 'L')
        aux_float = va_arg (AP_POINTER, long double);
      else
        aux_float = va_arg (AP_POINTER, 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_POINTER, 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 */
#undef AP_POINTER

/*----------------------------------------------------------------------------*/
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 */


/* workaround for an ABI-change on PPC and X86-64 */
#if defined(__GNUC__) && (defined (__powerpc__) || defined(__amd64__))
#define VA_ADDRESS(VAL) (VAL)
#else
#define VA_ADDRESS(VAL) (&(VAL))
#endif
/*============================================================================*/
char *ighmm_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 ((char *) VA_ADDRESS(ap), (char *) VA_ADDRESS(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, VA_ADDRESS(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);
  }
  va_end (ap);

  return (dst);
}                               /* ighmm_mprintf_va */
#undef VA_ADDRESS

/*============================================================================*/
char *ighmm_mprintf (char *dst, int maxlen, char *format, ...)
{
  va_list args;
  char *res;

  va_start (args, format);
  res = ighmm_mprintf_va (dst, maxlen, format, args);
  va_end (args);

  return (res);
}                               /* ighmm_mprintf */

/*============================================================================*/
char *ighmm_mprintf_va_dyn (char *dst, int maxlen, char *format, va_list args)
{
  char *res = NULL;

  res = ighmm_mprintf_va (dst, maxlen, format, args);
  if (!res || !dst || maxlen <= 0)
    return (res);
  if (strlen (res) < maxlen - 1)
    return (res);
  res = ighmm_mprintf_va (NULL, 0, format, args);
  return (res);
}                               /* ighmm_mprintf_va_dyn */


/*============================================================================*/
char *ighmm_mprintf_dyn (char *dst, int maxlen, char *format, ...)
{
  va_list args;
  char *res;

  va_start (args, format);
  res = ighmm_mprintf_va_dyn (dst, maxlen, format, args);
  va_end (args);

  return (res);
}                               /* ighmm_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 (ighmm_mprintf (dst, sizeof (dst), "%12s", format_i[i]));
    mes_win ("\t");
    mes_win (ighmm_mprintf (dst, sizeof (dst), format_i[i], 45));
    mes_win ("\t\t");
    mes_win (ighmm_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 (ighmm_mprintf (dst, sizeof (dst), "%12s", format_c[i]));
    mes_win ("\t");
    mes_win (ighmm_mprintf (dst, sizeof (dst), format_c[i], '*'));
    mes_win ("\n");
  }

  for (i = 0; i < sizeof (format_s) / sizeof (format_s[0]); i++) {
    mes_win (ighmm_mprintf (dst, sizeof (dst), "%12s", format_s[i]));
    mes_win ("\t");
    mes_win (ighmm_mprintf (dst, sizeof (dst), format_s[i], "zap"));
    mes_win ("\t\t");
    mes_win (ighmm_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 (ighmm_mprintf (dst, sizeof (dst), "%12s", format_f[i]));
    mes_win ("\t");
    mes_win (ighmm_mprintf (dst, sizeof (dst), format_f[i], 12.678));
    mes_win ("\t\t");
    mes_win (ighmm_mprintf (dst, sizeof (dst), format_f[i], -12.678));
    mes_win ("\n");
  }

  dyn = ighmm_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 ) */