2utf.c

一个UTF的源代码,可以提供参考

    }
  if (ret >= END_BOUNDARY)
    boundaries.last--;
  return (ret);
}

  char *
Str_str (char *haystack_, char *needle_)
{
  char *haystack, *needle;
  register char *n_, *n;
  register int index;

  haystack = xstrdup (haystack_);
  needle = xstrdup (needle_);
  n = haystack;
  n_ = haystack_;
  for (index = 0; index < 2; index++)
  {
    while (*n_)
      if (!(*n_ == '-' || *n_ == '_'))
	*n++ = *n_++;
      else
	n_++;
    *n = '\0';
    n = needle;
    n_ = needle_;
  }
  n = strstr (haystack, needle) ? haystack_ : NULL;
  free (haystack);
  free (needle);
  return (n);
}

  inline char *
Strtoupper (char *string)
{
  register int index;

  for (index = 0; string[index] != 0; index++)
    string[index] = toupper (string[index]);
  return string;
}

  inline char *
Strtolower (char *string)
{
  register int index;

  for (index = 0; string[index] != 0; index++)
    string[index] = tolower (string[index]);
  return string;
}

  int
Spit (wchar_t min, wchar_t max, wchar_t charmap[], char unknown_char)
{
  char s[22], header[] = "  0 1 2 3 4 5 6 7 8 9 A B C D E F  0 1 2 3 4 5 6 7 8 9 A B C D E F \n";
  register wchar_t index,t;
  register int length;
  int prefix_length;

  prefix_length = sprintf (s, "%.2lx", (long unsigned int) max);
  fprintf (charset_p->pipe, "%*c%s", prefix_length, ' ', header);
  for (index = min / 32 * 32; index <= max / 32 * 32 + 31; index++)
  {
    if (index % 32 == 0)
      fprintf (charset_p->pipe, "%*.2lX: ", prefix_length, (unsigned long) index);
    if (charset_p->type == ICONV) {
      Put_to_iconv_buf (index, charset_p);
      Put_to_iconv_buf (-1, charset_p);
    } else {
      t = charmap == NULL ? index : (charmap[index] >= 0x80 && charmap[index] < 0xA0 ? (wchar_t) '.' : charmap[index]);
      length = wctomb (s, t <= 0xFF && iscntrl(t) ? (wchar_t) '.' : t);
      /*
      if ((length == 1) && (((unsigned) s[0] < 0x20) || ((unsigned) s[0] == 0x7F)))
      {
	length = wctomb (s, (wchar_t) '.');
      }
      */
      if (length != -1)
      {
	if (fwrite (s, 1, length, charset_p->pipe) != (size_t) length)
	  Error (IO_err);
      }
      else if (putc (unknown_char, charset_p->pipe) == EOF)
	Error (IO_err);
    }
    if (index < 0x3000 || (index >= 0xF000 && index < 0xF900) || (index >= 0xFF60 && index < 0xFFE0) || index >= 0xFFE8)
      if (putc (' ', charset_p->pipe) == EOF)
	Error (IO_err);
    switch (index % 32)
    {
      case 31:
	putc ('\n', charset_p->pipe);
	break;
      case 15:
	putc (' ', charset_p->pipe);
    }
    if (index % (32 * 8) == (32 * 8 - 1))
      fprintf (charset_p->pipe, "%*c%s", prefix_length, ' ', header);
    if (index == 0x7FFFFFFF)
      break;
  }
  return (1);
}

  int
Validate_charset (char *charset_name, enum USASCII_is_subset_type USASCII_is_subset)
{
  int c, element;
  static int charsets_count = 0;
  static struct charset_type *charsets = NULL, *old_charset_p;
  struct charmap_file_type charmap_file =
  {NULL, DEFAULT};
  struct charset_type *charsets_old_addr;
  wchar_t wchar;

  if (Debug >= 5)
    fprintf (stderr, "Validate_charset('%s',%i), charset is '%s', old charset was '%s'\n", charset_name, USASCII_is_subset, charset_p->name, old_charset_p ? old_charset_p->name:NULL);

  if (charset_name != NULL)
  {
    old_charset_p = charset_p;

    if (charset_p->name != NULL && Strcasecmp (charset_name, charset_p->name) == 0)
    {
      if (Debug >= 7)
	fprintf (stderr, "Charset the same: '%s' \n", charset_name);
      if (USASCII_is_subset)
	if (!charset_p->USASCII_is_subset)
	{
	  charset_p = &USASCII_charset;
	  if (Debug >= 2)
	    fprintf (stderr, "US-ASCII isn't subset " "of '%s', changing to US-ASCII", charset_name);
	}
    }
    else if (Strcasecmp (charset_name, "US-ASCII") == 0)
    {
      charset_p = &USASCII_charset;
    }
    else if (strlen (charset_name) < (size_t) (Mail ? 4 : 2) ||Strcasecmp (charset_name, "'unknown'") == 0)
    {
      if (Debug && Strcasecmp (charset_name, "'unknown'") != 0)
	fprintf (stderr, "Too short charset name: `%s\'\n", charset_name);
      charset_p = &unknown_charset;
    }
    else if (Str_is_UTF8 (charset_name))
    {
      charset_p = &UTF8_charset;
    }
    else
    {
      for (element = charsets_count - 1; element >= 0; element--)
      { /* may be we have used that charset before */
	if (Strcasecmp (charsets[element].name, charset_name) == 0)
	{
	  charset_p = &charsets[element];
	  if (charset_p == old_charset_p)
	    Error (internal_err);
	  if (charset_p->type == BUF_PIPE)
	    goto Open; /* can't reuse buffered pipe second time */
	  else if (charset_p->type == ICONV)
	    iconv (charset_p->iconv_p->iconv_handle, NULL, NULL, NULL, NULL);
	  goto Return1;
	}
      }

      charsets_old_addr = charsets;
      charsets = xrealloc (charsets, (sizeof (struct charset_type)) * ++charsets_count);

      if (NULL != charsets_old_addr && old_charset_p >= charsets_old_addr && old_charset_p <= &charsets_old_addr[charsets_count - 2]) {
	    old_charset_p += charsets - charsets_old_addr;
      }
      charset_p = &charsets[charsets_count - 1];

Open:
      charset_p->type = UNKNOWN;
      charset_p->pipe = unknown_charset.pipe;
      strcpy (charset_p->name, charset_name);
      if (Debug >= 2)
	fprintf (stderr, "Changing charset from '%s' to '%s'\n", old_charset_p->name, charset_p->name);
      if (old_charset_p->type == BUF_PIPE && old_charset_p->pipe != charset_p->pipe) {
	pclose (old_charset_p->pipe);
	old_charset_p->pipe = NULL;
      } else {
	FLUSH_OUTPUT(old_charset_p);
      }

      if (iconv_only)
	Open_iconv(charset_p);
      else if (! Look_for_ext_charset (USASCII_is_subset)) {
	if (iconv_first)
	  Open_iconv(charset_p);
	if (charset_p->type == UNKNOWN)
	  if (Fopen_charmap (charset_p, &charmap_file))
	  {
	    charset_p->charmap = xmalloc (256 * sizeof (wchar_t));
	    c = Get_charmap (charset_p->charmap, &charmap_file, unknown_wchar);
	    if (EOF == fclose (charmap_file.stream))
	      Error (IO_err);
	    switch (c)
	    {
	      case err_few_chars:
		Error (bad_charmap_format);
	      case err_IO:
		Error (IO_err);
	      case err_internal:
		Error (internal_err);
	      case err_long:
		if (Debug >= 8)
		  fprintf (stderr, "2UTF: %s \n", long_file);
		break;
	      case err_short:
		if (verbose)
		  fprintf (stderr, "2UTF: %s: \n", incomplete_charmap);
		break;
	    }
	    charset_p->type = KNOWN;
	    charset_p->pipe = stdout;
	    charset_p->USASCII_is_subset = IS;
	    for (wchar = ' '; wchar <= '~'; wchar++)
	      if (charset_p->charmap[wchar] != wchar)
	      {
		charset_p->USASCII_is_subset = NO;
		if (USASCII_is_subset)
		  charset_p = &USASCII_charset;
		break;
	      }
	  } else if (!iconv_first) {
	    Open_iconv(charset_p);
	  }
      }
    }
    /* return (charset_p->type == UNKNOWN ? FALSE : TRUE); ???*/
Return1:
    if (Debug >= 2)
      fprintf (stderr, "Changing charset from '%s' to '%s' again\n", old_charset_p->name, charset_p->name);
    if (old_charset_p->type == BUF_PIPE && old_charset_p->pipe != charset_p->pipe)
    {
      pclose (old_charset_p->pipe);
      old_charset_p->pipe = NULL;
    }
    else
      FLUSH_OUTPUT(old_charset_p);
    return (charset_p->type == UNKNOWN ? FALSE : TRUE);

  }
  else
  {				/* restore charset selected before the current */
    if (Debug >= 2)
      fprintf (stderr, "Restoring charset from '%s' to '%s'\n", charset_p->name, old_charset_p->name);
    if (charset_p->type == BUF_PIPE)
    {
      pclose (charset_p->pipe);
      charset_p->pipe = NULL;
      charsets_count--;
    }
    else
      FLUSH_OUTPUT(charset_p);
    charset_p = old_charset_p;
    if (charset_p->type == BUF_PIPE)
      if (Look_for_ext_charset (USASCII_is_subset) == FALSE)
	fprintf (stderr, "2UTF: Can't find the same ext. charset name second time ?? \n");
    return (charset_p->type == UNKNOWN ? FALSE : TRUE);
  }
}

  inline void *
xmalloc (size_t size)
{
  register void *pointer = malloc (size);

  if (pointer == NULL)
    Error (out_of_mem);
  return pointer;
}

  inline void *
xrealloc (void *pointer, size_t size)
{
  register void *new_pointer = realloc (pointer, size);

  if (new_pointer == NULL)
    Error (out_of_mem);
  return new_pointer;
}

  inline char *
xstrdup (const char *string)
{
  return (strcpy (xmalloc (strlen (string) + 1), string));
}

/*
   inline char *
   xstrndup (const char *string, size_t size)
   {
   register char *new_string = strndup (string, size);

   if (new_string == NULL)
   Error (out_of_mem);
   return new_string;
   }
 */

  int
main (int argc, char *argv[])	/* char *env[]) */
{
#include "approx.c"

  /*FILE *charmap_file = NULL; */
  unsigned char default_unknown_char = 0x80;
  char unknown_char = default_unknown_char;
  char *charmap_filename = NULL, *ptr;
  unsigned char *next_token, /* s[max_string_length], */ *stop_char_ptr;
  const char *optstring = "248Cc:d::ef::Hhi:loprS::su::vVWw";
  const struct long2short_options_type long2short_options[] =
  {
    {
      "UCS-2", '2'
    }
    ,
    {
      "UCS2", '2'
    }
    ,
    {
      "ucs-2", '2'
    }
    ,
    {
      "ucs2", '2'
    }
    ,
    {
      "UCS-4", '4'
    }
    ,
    {
      "UCS4", '4'
    }
    ,
    {
      "ucs-4", '4'
    }
    ,
    {
      "ucs4", '4'
    }
    ,
    {
      "UCS-wchar_t", 'w'
    }
    ,
    {
      "ucs-wchar_t", 'w'
    }
    ,
    {
      "UTF-8", '8'
    }
    ,
    {
      "UTF8", '8'
    }
    ,
    {
      "utf-8", '8'
    }
    ,
    {
      "utf8", '8'
    }
    ,
    {
      "create-aliases", 'C'
    }
    ,
    {
      "charmap-file", 'c'
    }
    ,
    {
      "debug", 'd'
    }
    ,
    {
      "encode-headers", 'e'
    }
    ,
    {
      "format", 'f'
    }
    ,
    {
      "forward", 'o'
    }
    ,
    {
      "help", 'h'
    }
    ,
    {
      "?", 'h'
    }
    ,
    {
      "HTML", 'H'
    }
    ,
    {
      "html", 'H'
    }
    ,
    {
      "iconv", 'i'
    }
    ,
    {
      "list", 'l'
    }
    ,
    {
      "reverse", 'r'
    }
    ,
    {
      "show-charmap", 'W'
    }
    ,
    {
      "spit-glyphs", 'S'
    }
    ,
    {
      "switch-to-UTF-8", 's'
    }
    ,
    {
      "switch-to-UTF8", 's'
    }
    ,
    {
      "switch-to-utf-8", 's'
    }
    ,
    {
      "switch-to-utf8", 's'
    }
    ,
    {
      "unknown-char", 'u'
    }
    ,
    {
      "verbose", 'v'
    }
    ,
    {
      "version", 'V'
    }
    ,
    {
      "blurb", 'V'
    }
    ,
    {
      NULL, '\0'
    }
  };