if ((forward && ++idx >= run->data[pass].number) || (!forward && --idx < 0))
if (forward)
STRXFRM (STRING_TYPE *dest, const STRING_TYPE *src, size_t n)#elsesize_tSTRXFRM (STRING_TYPE *dest, const STRING_TYPE *src, size_t n, __locale_t l)#endif{#ifdef USE_IN_EXTENDED_LOCALE_MODEL  struct locale_data *current = l->__locales[LC_COLLATE];# if BYTE_ORDER == BIG_ENDIAN  const u_int32_t *collate_table = (const u_int32_t *)    current->values[_NL_ITEM_INDEX (_NL_COLLATE_TABLE_EB)].string;  const u_int32_t *collate_extra = (const u_int32_t *)    current->values[_NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EB)].string;# elif BYTE_ORDER == LITTLE_ENDIAN  const u_int32_t *collate_table = (const u_int32_t *)    current->values[_NL_ITEM_INDEX (_NL_COLLATE_TABLE_EL)].string;  const u_int32_t *collate_extra = (const u_int32_t *)    current->values[_NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EL)].string;# else#  error bizarre byte order# endif#endif  weight_t *forw = NULL;  weight_t *backw = NULL;  size_t pass;  size_t written;  /* If the current locale does not specify locale data we use normal     8-bit string comparison.  */  if (collate_nrules == 0)    {      if (n != 0)	STPNCPY (dest, src, n);      return STRLEN (src);    }  /* Handle an empty string as a special case.  */  if (*src == '\0')    {      if (n != 0)	*dest = '\0';      return 1;    }  /* Get full information about the string.  This means we get     information for all passes in a special data structure.  */  get_string (src, forw, backw);  /* Now we have all the information.  In at most the given number of     passes we can finally decide about the order.  */  written = 0;  for (pass = 0; pass < collate_nrules; ++pass)    {      int forward = (collate_rules[pass] & sort_forward) != 0;      const weight_t *run = forward ? forw : backw;      int idx = forward ? 0 : run->data[pass].number - 1;      while (1)	{	  int ignore = 0;	  u_int32_t w = 0;	  /* Here we have to check for IGNORE entries.  If these are	     found we count them and go on with he next value.  */	  while (run != NULL		 && ((w = run->data[pass].value[idx])		     == (u_int32_t) IGNORE_CHAR))	    {	      ++ignore;	      if (forward		  ? ++idx >= run->data[pass].number		  : --idx < 0)		{		  weight_t *nextp = forward ? run->next : run->prev;		  if (nextp == NULL)		    {		      w = 0;		      /* No more non-INGOREd elements means lowest			 possible value.  */		      ignore = -1;		    }		  else		    idx = forward ? 0 : nextp->data[pass].number - 1;		  run = nextp;		}	    }	  /* Stop if all characters are processed.  */	  if (run == NULL)	    break;	  /* Now we have information of the number of ignored weights	     and the value of the next weight.  We have to add 2	     because 0 means EOS and 1 is the intermediate string end.  */	  if ((collate_rules[pass] & sort_position) != 0)	    written = print_val (ignore + 2, dest, n, written);	  if (w != 0)	    written = print_val (w, dest, n, written);	  /* We have to increment the index counters.  */	  if ((forward && ++idx >= run->data[pass].number)	      || (!forward && --idx < 0))	    {	      if (forward)		{		  run = run->next;		  idx = 0;		}	      else		{		  run = run->prev;		  if (run != NULL)		    idx = run->data[pass].number - 1;		}	    }	}      /* Write marker for end of word.  */      if (pass + 1 < collate_nrules)	written = print_val (1, dest, n, written);    }  /* Terminate string.  */  if (written < n)    dest[written] = L_('\0');  /* Return length without counting the terminating '\0'.  */  return written;}