Back to GNU Libidn 1.29 Homepage
GNU Libidn 1.29 Cyclomatic Complexity Report

Report generated at: Sun Aug 10 22:55:10 CEST 2014

Summary

Total number of functions | 72
Number of low risk functions | 61
Number of moderate risk functions | 6
Number of high risk functions | 5
Number of untestable functions | 0

Details for all functions

| Cyclomatic Complexity | Risk Evaluation
| 0 - 10 | Simple module, without much risk
| 11 - 20 | More complex module, moderate risk
| 21 - 50 | Complex module, high risk
| greater than 50 | Untestable module, very high risk

| Function Name | Modified Cyclo | Number of Statements | Number of Lines | Source File
↓ | idna_to_ascii_4i | 38 | 94 | 194 | idna.c
    int
    idna_to_ascii_4i (const uint32_t * in, size_t inlen, char *out, int flags)
    {
      size_t len, outlen;
      uint32_t *src;		/* XXX don't need to copy data? */
      int rc;

      /*
       * ToASCII consists of the following steps:
       *
       * 1. If all code points in the sequence are in the ASCII range (0..7F)
       * then skip to step 3.
       */

      {
        size_t i;
        int inasciirange;

        inasciirange = 1;
        for (i = 0; i gt; 0x7F)
    	inasciirange = 0;
        if (inasciirange)
          {
    	src = malloc (sizeof (in[0]) * (inlen + 1));
    	if (src == NULL)
    	  return IDNA_MALLOC_ERROR;

    	memcpy (src, in, sizeof (in[0]) * inlen);
    	src[inlen] = 0;

    	goto step3;
          }
      }

      /*
       * 2. Perform the steps specified in [NAMEPREP] and fail if there is
       * an error. The AllowUnassigned flag is used in [NAMEPREP].
       */

      {
        char *p;

        p = stringprep_ucs4_to_utf8 (in, (ssize_t) inlen, NULL, NULL);
        if (p == NULL)
          return IDNA_MALLOC_ERROR;

        len = strlen (p);
        do
          {
    	char *newp;

    	len = 2 * len + 10;	/* XXX better guess? */
    	newp = realloc (p, len);
    	if (newp == NULL)
    	  {
    	    free (p);
    	    return IDNA_MALLOC_ERROR;
    	  }
    	p = newp;

    	if (flags & IDNA_ALLOW_UNASSIGNED)
    	  rc = stringprep_nameprep (p, len);
    	else
    	  rc = stringprep_nameprep_no_unassigned (p, len);
          }
        while (rc == STRINGPREP_TOO_SMALL_BUFFER);

        if (rc != STRINGPREP_OK)
          {
    	free (p);
    	return IDNA_STRINGPREP_ERROR;
          }

        src = stringprep_utf8_to_ucs4 (p, -1, NULL);

        free (p);

        if (!src)
          return IDNA_MALLOC_ERROR;
      }

    step3:
      /*
       * 3. If the UseSTD3ASCIIRules flag is set, then perform these checks:
       *
       * (a) Verify the absence of non-LDH ASCII code points; that is,
       * the absence of 0..2C, 2E..2F, 3A..40, 5B..60, and 7B..7F.
       *
       * (b) Verify the absence of leading and trailing hyphen-minus;
       * that is, the absence of U+002D at the beginning and end of
       * the sequence.
       */

      if (flags & IDNA_USE_STD3_ASCII_RULES)
        {
          size_t i;

          for (i = 0; src[i]; i++)
    	if (src[i] gt;= 0x3A && src[i] gt;= 0x5B && src[i] gt;= 0x7B && src[i] gt; 0 && src[i - 1] == 0x002D))
    	{
    	  free (src);
    	  return IDNA_CONTAINS_MINUS;
    	}
        }

      /*
       * 4. If all code points in the sequence are in the ASCII range
       * (0..7F), then skip to step 8.
       */

      {
        size_t i;
        int inasciirange;

        inasciirange = 1;
        for (i = 0; src[i]; i++)
          {
    	if (src[i] >gt; 0x7F)
    	  inasciirange = 0;
    	/* copy string to output buffer if we are about to skip to step8 */
    	if (i gt; 63)
        return IDNA_INVALID_LENGTH;

      return IDNA_SUCCESS;
    }
↓ | stringprep_4i | 30 | 76 | 137 | stringprep.c
    int
    stringprep_4i (uint32_t * ucs4, size_t * len, size_t maxucs4len,
    	       Stringprep_profile_flags flags,
    	       const Stringprep_profile * profile)
    {
      size_t i, j;
      ssize_t k;
      size_t ucs4len = *len;
      int rc;

      for (i = 0; profile[i].operation; i++)
        {
          switch (profile[i].operation)
    	{
    	case STRINGPREP_NFKC:
    	  {
    	    uint32_t *q = 0;

    	    if (UNAPPLICAPLEFLAGS (flags, profile[i].flags))
    	      break;

    	    if (flags & STRINGPREP_NO_NFKC && !profile[i].flags)
    	      /* Profile requires NFKC, but callee asked for no NFKC. */
    	      return STRINGPREP_FLAG_ERROR;

    	    q = stringprep_ucs4_nfkc_normalize (ucs4, ucs4len);
    	    if (!q)
    	      return STRINGPREP_NFKC_FAILED;

    	    for (ucs4len = 0; q[ucs4len]; ucs4len++)
    	      ;

    	    if (ucs4len >gt;= maxucs4len)
    	      {
    		free (q);
    		return STRINGPREP_TOO_SMALL_BUFFER;
    	      }

    	    memcpy (ucs4, q, ucs4len * sizeof (ucs4[0]));

    	    free (q);
    	  }
    	  break;

    	case STRINGPREP_PROHIBIT_TABLE:
    	  k = stringprep_find_string_in_table (ucs4, ucs4len,
    					       NULL, profile[i].table);
    	  if (k != -1)
    	    return STRINGPREP_CONTAINS_PROHIBITED;
    	  break;

    	case STRINGPREP_UNASSIGNED_TABLE:
    	  if (UNAPPLICAPLEFLAGS (flags, profile[i].flags))
    	    break;
    	  if (flags & STRINGPREP_NO_UNASSIGNED)
    	    {
    	      k = stringprep_find_string_in_table
    		(ucs4, ucs4len, NULL, profile[i].table);
    	      if (k != -1)
    		return STRINGPREP_CONTAINS_UNASSIGNED;
    	    }
    	  break;

    	case STRINGPREP_MAP_TABLE:
    	  if (UNAPPLICAPLEFLAGS (flags, profile[i].flags))
    	    break;
    	  rc = stringprep_apply_table_to_string
    	    (ucs4, &ucs4len, maxucs4len, profile[i].table);
    	  if (rc != STRINGPREP_OK)
    	    return rc;
    	  break;

    	case STRINGPREP_BIDI_PROHIBIT_TABLE:
    	case STRINGPREP_BIDI_RAL_TABLE:
    	case STRINGPREP_BIDI_L_TABLE:
    	  break;

    	case STRINGPREP_BIDI:
    	  {
    	    int done_prohibited = 0;
    	    int done_ral = 0;
    	    int done_l = 0;
    	    size_t contains_ral = SIZE_MAX;
    	    size_t contains_l = SIZE_MAX;

    	    for (j = 0; profile[j].operation; j++)
    	      if (profile[j].operation == STRINGPREP_BIDI_PROHIBIT_TABLE)
    		{
    		  done_prohibited = 1;
    		  k = stringprep_find_string_in_table (ucs4, ucs4len,
    						       NULL,
    						       profile[j].table);
    		  if (k != -1)
    		    return STRINGPREP_BIDI_CONTAINS_PROHIBITED;
    		}
    	      else if (profile[j].operation == STRINGPREP_BIDI_RAL_TABLE)
    		{
    		  done_ral = 1;
    		  if (stringprep_find_string_in_table
    		      (ucs4, ucs4len, NULL, profile[j].table) != -1)
    		    contains_ral = j;
    		}
    	      else if (profile[j].operation == STRINGPREP_BIDI_L_TABLE)
    		{
    		  done_l = 1;
    		  if (stringprep_find_string_in_table
    		      (ucs4, ucs4len, NULL, profile[j].table) != -1)
    		    contains_l = j;
    		}

    	    if (!done_prohibited || !done_ral || !done_l)
    	      return STRINGPREP_PROFILE_ERROR;

    	    if (contains_ral != SIZE_MAX && contains_l != SIZE_MAX)
    	      return STRINGPREP_BIDI_BOTH_L_AND_RAL;

    	    if (contains_ral != SIZE_MAX)
    	      {
    		if (!(stringprep_find_character_in_table
    		      (ucs4[0], profile[contains_ral].table) != -1 &&
    		      stringprep_find_character_in_table
    		      (ucs4[ucs4len - 1], profile[contains_ral].table) != -1))
    		  return STRINGPREP_BIDI_LEADTRAIL_NOT_RAL;
    	      }
    	  }
    	  break;

    	default:
    	  return STRINGPREP_PROFILE_ERROR;
    	  break;
    	}
        }

      *len = ucs4len;

      return STRINGPREP_OK;
    }
↓ | _g_utf8_normalize_wc | 30 | 76 | 135 | nfkc.c
    static gunichar *
    _g_utf8_normalize_wc (const gchar * str, gssize max_len, GNormalizeMode mode)
    {
      gsize n_wc;
      gunichar *wc_buffer;
      const char *p;
      gsize last_start;
      gboolean do_compat = (mode == G_NORMALIZE_NFKC || mode == G_NORMALIZE_NFKD);
      gboolean do_compose = (mode == G_NORMALIZE_NFC || mode == G_NORMALIZE_NFKC);

      n_wc = 0;
      p = str;
      while ((max_len gt;= SBase && wc gt;= SBase && wc gt; 0)
    	{
    	  cc = COMBINING_CLASS (wc_buffer[old_n_wc]);

    	  if (cc == 0)
    	    {
    	      g_unicode_canonical_ordering (wc_buffer + last_start,
    					    n_wc - last_start);
    	      last_start = old_n_wc;
    	    }
    	}

          p = g_utf8_next_char (p);
        }

      if (n_wc >gt; 0)
        {
          g_unicode_canonical_ordering (wc_buffer + last_start,
    				    n_wc - last_start);
          // dead assignment: last_start = n_wc;
        }

      wc_buffer[n_wc] = 0;

      /* All decomposed and reordered */

      if (do_compose && n_wc >gt; 0)
        {
          gsize i, j;
          int last_cc = 0;
          last_start = 0;

          for (i = 0; i gt; 0 &&
    	      (last_cc == 0 || last_cc != cc) &&
    	      combine (wc_buffer[last_start], wc_buffer[i],
    		       &wc_buffer[last_start]))
    	    {
    	      for (j = i + 1; j
↓ | punycode_encode | 22 | 57 | 111 | punycode.c
    int
    punycode_encode (size_t input_length,
    		 const punycode_uint input[],
    		 const unsigned char case_flags[],
    		 size_t * output_length, char output[])
    {
      punycode_uint input_len, n, delta, h, b, bias, j, m, q, k, t;
      size_t out, max_out;

      /* The Punycode spec assumes that the input length is the same type */
      /* of integer as a code point, so we need to convert the size_t to  */
      /* a punycode_uint, which could overflow.                           */

      if (input_length >gt; maxint)
        return punycode_overflow;
      input_len = (punycode_uint) input_length;

      /* Initialize the state: */

      n = initial_n;
      delta = 0;
      out = 0;
      max_out = *output_length;
      bias = initial_bias;

      /* Handle the basic code points: */

      for (j = 0; j gt; 0)
        output[out++] = delimiter;

      /* Main encoding loop: */

      while (h gt;= n && input[j] gt; state to gt;, but guard against overflow: */

          if (m - n >gt; (maxint - delta) / (h + 1))
    	return punycode_overflow;
          delta += (m - n) * (h + 1);
          n = m;

          for (j = 0; j gt;= max_out)
    		    return punycode_big_output;
    		  t = k gt;= bias + tmax ? tmax : k - bias;
    		  if (q
↓ | punycode_decode | 21 | 59 | 101 | punycode.c
    int
    punycode_decode (size_t input_length,
    		 const char input[],
    		 size_t * output_length,
    		 punycode_uint output[], unsigned char case_flags[])
    {
      punycode_uint n, out, i, max_out, bias, oldi, w, k, digit, t;
      size_t b, j, in;

      /* Initialize the state: */

      n = initial_n;
      out = i = 0;
      max_out = *output_length >gt; maxint ? maxint
        : (punycode_uint) * output_length;
      bias = initial_bias;

      /* Handle the basic code points:  Let b be the number of input code */
      /* points before the last delimiter, or 0 if there is none, then    */
      /* copy the first b code points to the output.                      */

      for (b = j = 0; j gt; max_out)
        return punycode_big_output;

      for (j = 0; j gt; 0 ? b + 1 : 0; in gt;= input_length)
    	    return punycode_bad_input;
    	  digit = decode_digit (input[in++]);
    	  if (digit >gt;= base)
    	    return punycode_bad_input;
    	  if (digit >gt; (maxint - i) / w)
    	    return punycode_overflow;
    	  i += digit * w;
    	  t = k gt;= bias + tmax ? tmax : k - bias;
    	  if (digit gt; maxint / (base - t))
    	    return punycode_overflow;
    	  w *= (base - t);
    	}

          bias = adapt (i - oldi, out + 1, oldi == 0);

          /* i was supposed to wrap around from out+1 to 0,   */
          /* incrementing n each time, so we'll fix that now: */

          if (i / (out + 1) >gt; maxint - n)
    	return punycode_overflow;
          n += i / (out + 1);
          i %= (out + 1);

          /* Insert n at position i of the output: */

          /* not needed for Punycode: */
          /* if (basic(n)) return punycode_invalid_input; */
          if (out >gt;= max_out)
    	return punycode_big_output;

          if (case_flags)
    	{
    	  memmove (case_flags + i + 1, case_flags + i, out - i);
    	  /* Case of last ASCII code point determines case flag: */
    	  case_flags[i] = flagged (input[in - 1]);
    	}

          memmove (output + i + 1, output + i, (out - i) * sizeof *output);
          output[i++] = n;
        }

      *output_length = (size_t) out;
      /* cannot overflow because out
↓ | idna_to_ascii_4z | 15 | 48 | 87 | idna.c
    int
    idna_to_ascii_4z (const uint32_t * input, char **output, int flags)
    {
      const uint32_t *start = input;
      const uint32_t *end;
      char buf[64];
      char *out = NULL;
      int rc;

      /* 1) Whenever dots are used as label separators, the following
         characters MUST be recognized as dots: U+002E (full stop),
         U+3002 (ideographic full stop), U+FF0E (fullwidth full stop),
         U+FF61 (halfwidth ideographic full stop). */

      if (input[0] == 0)
        {
          /* Handle implicit zero-length root label. */
          *output = malloc (1);
          if (!*output)
    	return IDNA_MALLOC_ERROR;
          strcpy (*output, "");
          return IDNA_SUCCESS;
        }

      if (DOTP (input[0]) && input[1] == 0)
        {
          /* Handle explicit zero-length root label. */
          *output = malloc (2);
          if (!*output)
    	return IDNA_MALLOC_ERROR;
          strcpy (*output, ".");
          return IDNA_SUCCESS;
        }

      *output = NULL;
      do
        {
          end = start;

          for (; *end && !DOTP (*end); end++)
    	;

          if (*end == '\0' && start == end)
    	{
    	  /* Handle explicit zero-length root label. */
    	  buf[0] = '\0';
    	}
          else
    	{
    	  rc = idna_to_ascii_4i (start, (size_t) (end - start), buf, flags);
    	  if (rc != IDNA_SUCCESS)
    	    {
    	      free (out);
    	      return rc;
    	    }
    	}

          if (out)
    	{
    	  size_t l = strlen (out) + 1 + strlen (buf) + 1;
    	  char *newp = realloc (out, l);
    	  if (!newp)
    	    {
    	      free (out);
    	      return IDNA_MALLOC_ERROR;
    	    }
    	  out = newp;
    	  strcat (out, ".");
    	  strcat (out, buf);
    	}
          else
    	{
    	  size_t l = strlen (buf) + 1;
    	  out = (char *) malloc (l);
    	  if (!out)
    	    return IDNA_MALLOC_ERROR;
    	  strcpy (out, buf);
    	}

          start = end + 1;
        }
      while (*end);

      *output = out;

      return IDNA_SUCCESS;
    }
↓ | tld_get_4 | 14 | 24 | 37 | tld.c
    int
    tld_get_4 (const uint32_t * in, size_t inlen, char **out)
    {
      const uint32_t *ipos;
      size_t olen;

      *out = NULL;
      if (!in || inlen == 0)
        return TLD_NODATA;

      ipos = &in[inlen - 1];
      olen = 0;
      /* Scan backwards for non(latin)letters. */
      while (ipos >gt;= in && ((*ipos >gt;= 0x41 && *ipos gt;= 0x61 && *ipos gt; 0 && ipos >gt;= in && DOTP (*ipos))
        {
          /* Found something that appears a TLD. */
          char *out_s = malloc (sizeof (char) * (olen + 1));
          char *opos = out_s;

          if (!opos)
    	return TLD_MALLOC_ERROR;

          ipos++;
          /* Transcribe to lowercase ascii string. */
          for (; ipos gt; 0x5A ? *ipos : *ipos + 0x20;
          *opos = 0;
          *out = out_s;
          return TLD_SUCCESS;
        }

      return TLD_NO_TLD;
    }
↓ | idna_to_unicode_internal | 12 | 47 | 118 | idna.c
    static int
    idna_to_unicode_internal (char *utf8in,
    			  uint32_t * out, size_t * outlen, int flags)
    {
      int rc;
      char tmpout[64];
      size_t utf8len = strlen (utf8in) + 1;
      size_t addlen = 0;

      /*
       * ToUnicode consists of the following steps:
       *
       * 1. If the sequence contains any code points outside the ASCII range
       * (0..7F) then proceed to step 2, otherwise skip to step 3.
       */

      {
        size_t i;
        int inasciirange;

        inasciirange = 1;
        for (i = 0; utf8in[i]; i++)
          if (utf8in[i] & ~0x7F)
    	inasciirange = 0;
        if (inasciirange)
          goto step3;
      }

      /*
       * 2. Perform the steps specified in [NAMEPREP] and fail if there is an
       * error. (If step 3 of ToASCII is also performed here, it will not
       * affect the overall behavior of ToUnicode, but it is not
       * necessary.) The AllowUnassigned flag is used in [NAMEPREP].
       */
      do
        {
          char *newp = realloc (utf8in, utf8len + addlen);
          if (newp == NULL)
    	{
    	  free (utf8in);
    	  return IDNA_MALLOC_ERROR;
    	}
          utf8in = newp;
          if (flags & IDNA_ALLOW_UNASSIGNED)
    	rc = stringprep_nameprep (utf8in, utf8len + addlen);
          else
    	rc = stringprep_nameprep_no_unassigned (utf8in, utf8len + addlen);
          addlen += 1;
        }
      while (rc == STRINGPREP_TOO_SMALL_BUFFER);

      if (rc != STRINGPREP_OK)
        {
          free (utf8in);
          return IDNA_STRINGPREP_ERROR;
        }

      /* 3. Verify that the sequence begins with the ACE prefix, and save a
       * copy of the sequence.
       * ... The ToASCII and ToUnicode operations MUST recognize the ACE
       prefix in a case-insensitive manner.
       */

    step3:
      if (c_strncasecmp (utf8in, IDNA_ACE_PREFIX, strlen (IDNA_ACE_PREFIX)) != 0)
        {
          free (utf8in);
          return IDNA_NO_ACE_PREFIX;
        }

      /* 4. Remove the ACE prefix.
       */

      memmove (utf8in, &utf8in[strlen (IDNA_ACE_PREFIX)],
    	   strlen (utf8in) - strlen (IDNA_ACE_PREFIX) + 1);

      /* 5. Decode the sequence using the decoding algorithm in [PUNYCODE]
       * and fail if there is an error. Save a copy of the result of
       * this step.
       */

      (*outlen)--;			/* reserve one for the zero */

      rc = punycode_decode (strlen (utf8in), utf8in, outlen, out, NULL);
      if (rc != PUNYCODE_SUCCESS)
        {
          free (utf8in);
          return IDNA_PUNYCODE_ERROR;
        }

      out[*outlen] = 0;		/* add zero */

      /* 6. Apply ToASCII.
       */

      rc = idna_to_ascii_4i (out, *outlen, tmpout, flags);
      if (rc != IDNA_SUCCESS)
        {
          free (utf8in);
          return rc;
        }

      /* 7. Verify that the result of step 6 matches the saved copy from
       * step 3, using a case-insensitive ASCII comparison.
       */

      if (c_strcasecmp (utf8in, tmpout + strlen (IDNA_ACE_PREFIX)) != 0)
        {
          free (utf8in);
          return IDNA_ROUNDTRIP_VERIFY_ERROR;
        }

      /* 8. Return the saved copy from step 5.
       */

      free (utf8in);
      return IDNA_SUCCESS;
    }
↓ | combine | 12 | 21 | 54 | nfkc.c
    static gboolean
    combine (gunichar a, gunichar b, gunichar * result)
    {
      gushort index_a, index_b;

      if (combine_hangul (a, b, result))
        return TRUE;

      index_a = COMPOSE_INDEX (a);

      if (index_a >gt;= COMPOSE_FIRST_SINGLE_START && index_a gt;= COMPOSE_SECOND_SINGLE_START)
        {
          if (a ==
    	  compose_second_single[index_b - COMPOSE_SECOND_SINGLE_START][0])
    	{
    	  *result =
    	    compose_second_single[index_b - COMPOSE_SECOND_SINGLE_START][1];
    	  return TRUE;
    	}
          else
    	return FALSE;
        }

      if (index_a >gt;= COMPOSE_FIRST_START && index_a gt;= COMPOSE_SECOND_START
          && index_b
↓ | g_utf8_to_ucs4_fast | 11 | 38 | 75 | nfkc.c
    static gunichar *
    g_utf8_to_ucs4_fast (const gchar * str, glong len, glong * items_written)
    {
      gunichar *result;
      gsize n_chars, i;
      const gchar *p;

      g_return_val_if_fail (str != NULL, NULL);

      p = str;
      n_chars = 0;
      if (len
↓ | _tld_checkchar | 11 | 15 | 28 | tld.c
    static int
    _tld_checkchar (uint32_t ch, const Tld_table * tld)
    {
      const Tld_table_element *s, *e, *m;

      if (!tld)
        return TLD_SUCCESS;

      /* Check for [-a-z0-9.]. */
      if ((ch >gt;= 0x61 && ch gt;= 0x30 && ch gt;valid;
      e = s + tld->gt;nvalid;
      while (s gt;>gt; 1);
          if (ch gt;start)
    	e = m;
          else if (ch >gt; m->gt;end)
    	s = m + 1;
          else
    	return TLD_SUCCESS;
        }

      return TLD_INVALID;
    }
| find_decomposition | 10 | 21 | 41 | nfkc.c
| combine_hangul | 10 | 11 | 23 | nfkc.c
| g_ucs4_to_utf8 | 9 | 26 | 42 | nfkc.c
| stringprep_profile | 9 | 24 | 38 | stringprep.c
| g_utf8_strlen | 9 | 16 | 37 | nfkc.c
| g_unichar_to_utf8 | 8 | 28 | 51 | nfkc.c
| idna_to_unicode_4z4z | 7 | 37 | 61 | idna.c
| g_unicode_canonical_ordering | 7 | 24 | 36 | nfkc.c
| pr29_4 | 7 | 15 | 27 | pr29.c
| stringprep_find_character_in_table | 6 | 8 | 21 | stringprep.c
| stringprep | 6 | 30 | 53 | stringprep.c
| tld_get_table | 5 | 9 | 14 | tld.c
| stringprep_locale_charset | 5 | 7 | 17 | toutf8.c
| stringprep_apply_table_to_string | 5 | 13 | 27 | stringprep.c
| tld_check_4t | 5 | 13 | 24 | tld.c
| tld_default_table | 4 | 8 | 16 | tld.c
| decode_digit | 4 | 4 | 6 | punycode.c
| tld_check_4 | 4 | 13 | 28 | tld.c
| idna_to_unicode_44i | 4 | 12 | 24 | idna.c
| decompose_hangul | 4 | 10 | 21 | nfkc.c
| stringprep_find_string_in_table | 4 | 10 | 19 | stringprep.c
| first_column | 4 | 10 | 12 | pr29.c
| adapt | 3 | 9 | 16 | punycode.c
| stringprep_4zi_1 | 3 | 8 | 18 | stringprep.c
| combinationclass | 3 | 7 | 11 | pr29.c
| in_last_column_row | 3 | 7 | 11 | pr29.c
| tld_check_4z | 3 | 6 | 14 | tld.c
| stringprep_4zi | 3 | 6 | 12 | stringprep.c
| tld_check_4tz | 3 | 6 | 13 | tld.c
| tld_get_4z | 3 | 6 | 13 | tld.c
| stringprep_check_version | 3 | 3 | 8 | version.c
| tld_get_z | 3 | 14 | 22 | tld.c
| tld_check_8z | 3 | 11 | 21 | tld.c
| tld_check_lz | 3 | 10 | 20 | tld.c
| tld_strerror | 2 | 17 | 40 | strerror-tld.c
| punycode_strerror | 2 | 13 | 32 | strerror-punycode.c
| pr29_strerror | 2 | 11 | 28 | strerror-pr29.c
| idna_to_unicode_8z4z | 2 | 9 | 16 | idna.c
| idna_to_ascii_8z | 2 | 9 | 18 | idna.c
| idna_to_unicode_lzlz | 2 | 8 | 15 | idna.c
| idna_to_unicode_8zlz | 2 | 8 | 15 | idna.c
| idna_to_unicode_8z8z | 2 | 8 | 15 | idna.c
| idna_to_ascii_lz | 2 | 8 | 16 | idna.c
| g_utf8_get_char | 2 | 8 | 14 | nfkc.c
| pr29_8z | 2 | 8 | 16 | pr29.c
| stringprep_convert | 2 | 7 | 16 | toutf8.c
| pr29_4z | 2 | 6 | 10 | pr29.c
| encode_basic | 2 | 2 | 6 | punycode.c
| stringprep_strerror | 2 | 29 | 64 | strerror-stringprep.c
| idna_strerror | 2 | 29 | 64 | strerror-idna.c
| stringprep_ucs4_nfkc_normalize | 1 | 6 | 12 | nfkc.c
| g_utf8_normalize | 1 | 5 | 11 | nfkc.c
| stringprep_unichar_to_utf8 | 1 | 1 | 5 | nfkc.c
| stringprep_utf8_to_unichar | 1 | 1 | 5 | nfkc.c
| idn_free | 1 | 1 | 5 | idn-free.c
| stringprep_utf8_to_locale | 1 | 1 | 5 | toutf8.c
| stringprep_locale_to_utf8 | 1 | 1 | 5 | toutf8.c
| stringprep_utf8_nfkc_normalize | 1 | 1 | 5 | nfkc.c
| encode_digit | 1 | 1 | 7 | punycode.c
| stringprep_ucs4_to_utf8 | 1 | 1 | 7 | nfkc.c
| stringprep_utf8_to_ucs4 | 1 | 1 | 5 | nfkc.c

Copyright (c) 2007, 2008 Free Software Foundation, Inc.