tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hgo...@apache.org
Subject svn commit: r532238 - in /tomcat/connectors/trunk/jk/native/common: ap_snprintf.c ap_snprintf.h jk_connect.c jk_map.c jk_msg_buff.c jk_util.c
Date Wed, 25 Apr 2007 07:48:38 GMT
Author: hgomez
Date: Wed Apr 25 00:48:37 2007
New Revision: 532238

URL: http://svn.apache.org/viewvc?view=rev&rev=532238
Log:
Tab police. Revert to old stat() in read map

Modified:
    tomcat/connectors/trunk/jk/native/common/ap_snprintf.c
    tomcat/connectors/trunk/jk/native/common/ap_snprintf.h
    tomcat/connectors/trunk/jk/native/common/jk_connect.c
    tomcat/connectors/trunk/jk/native/common/jk_map.c
    tomcat/connectors/trunk/jk/native/common/jk_msg_buff.c
    tomcat/connectors/trunk/jk/native/common/jk_util.c

Modified: tomcat/connectors/trunk/jk/native/common/ap_snprintf.c
URL: http://svn.apache.org/viewvc/tomcat/connectors/trunk/jk/native/common/ap_snprintf.c?view=diff&rev=532238&r1=532237&r2=532238
==============================================================================
--- tomcat/connectors/trunk/jk/native/common/ap_snprintf.c (original)
+++ tomcat/connectors/trunk/jk/native/common/ap_snprintf.c Wed Apr 25 00:48:37 2007
@@ -101,15 +101,15 @@
     register int r2;
     double fi, fj;
     register char *p, *p1;
-    
+
     if (ndigits >= NDIG - 1)
-	ndigits = NDIG - 2;
+  ndigits = NDIG - 2;
     r2 = 0;
     *sign = 0;
     p = &buf[0];
     if (arg < 0) {
-	*sign = 1;
-	arg = -arg;
+  *sign = 1;
+  arg = -arg;
     }
     arg = modf(arg, &fi);
     p1 = &buf[NDIG];
@@ -117,53 +117,53 @@
      * Do integer part
      */
     if (fi != 0) {
-	p1 = &buf[NDIG];
-	while (p1 > &buf[0] && fi != 0) {
-	    fj = modf(fi / 10, &fi);
-	    *--p1 = (int) ((fj + .03) * 10) + '0';
-	    r2++;
-	}
-	while (p1 < &buf[NDIG])
-	    *p++ = *p1++;
+  p1 = &buf[NDIG];
+  while (p1 > &buf[0] && fi != 0) {
+      fj = modf(fi / 10, &fi);
+      *--p1 = (int) ((fj + .03) * 10) + '0';
+      r2++;
+  }
+  while (p1 < &buf[NDIG])
+      *p++ = *p1++;
     }
     else if (arg > 0) {
-	while ((fj = arg * 10) < 1) {
-	    arg = fj;
-	    r2--;
-	}
+  while ((fj = arg * 10) < 1) {
+      arg = fj;
+      r2--;
+  }
     }
     p1 = &buf[ndigits];
     if (eflag == 0)
-	p1 += r2;
+  p1 += r2;
     *decpt = r2;
     if (p1 < &buf[0]) {
-	buf[0] = '\0';
-	return (buf);
+  buf[0] = '\0';
+  return (buf);
     }
     while (p <= p1 && p < &buf[NDIG]) {
-	arg *= 10;
-	arg = modf(arg, &fj);
-	*p++ = (int) fj + '0';
+  arg *= 10;
+  arg = modf(arg, &fj);
+  *p++ = (int) fj + '0';
     }
     if (p1 >= &buf[NDIG]) {
-	buf[NDIG - 1] = '\0';
-	return (buf);
+  buf[NDIG - 1] = '\0';
+  return (buf);
     }
     p = p1;
     *p1 += 5;
     while (*p1 > '9') {
-	*p1 = '0';
-	if (p1 > buf)
-	    ++ * --p1;
-	else {
-	    *p1 = '1';
-	    (*decpt)++;
-	    if (eflag == 0) {
-		if (p > buf)
-		    *p = '0';
-		p++;
-	    }
-	}
+  *p1 = '0';
+  if (p1 > buf)
+      ++ * --p1;
+  else {
+      *p1 = '1';
+      (*decpt)++;
+      if (eflag == 0) {
+    if (p > buf)
+        *p = '0';
+    p++;
+      }
+  }
     }
     *p = '\0';
     return (buf);
@@ -194,51 +194,51 @@
     p1 = ap_ecvt(number, ndigit, &decpt, &sign, buf1);
     p2 = buf;
     if (sign)
-	*p2++ = '-';
+  *p2++ = '-';
     for (i = ndigit - 1; i > 0 && p1[i] == '0'; i--)
-	ndigit--;
+  ndigit--;
     if ((decpt >= 0 && decpt - ndigit > 4)
-	|| (decpt < 0 && decpt < -3)) {		/* use E-style */
-	decpt--;
-	*p2++ = *p1++;
-	*p2++ = '.';
-	for (i = 1; i < ndigit; i++)
-	    *p2++ = *p1++;
-	*p2++ = 'e';
-	if (decpt < 0) {
-	    decpt = -decpt;
-	    *p2++ = '-';
-	}
-	else
-	    *p2++ = '+';
-	if (decpt / 100 > 0)
-	    *p2++ = decpt / 100 + '0';
-	if (decpt / 10 > 0)
-	    *p2++ = (decpt % 100) / 10 + '0';
-	*p2++ = decpt % 10 + '0';
+  || (decpt < 0 && decpt < -3)) {		/* use E-style */
+  decpt--;
+  *p2++ = *p1++;
+  *p2++ = '.';
+  for (i = 1; i < ndigit; i++)
+      *p2++ = *p1++;
+  *p2++ = 'e';
+  if (decpt < 0) {
+      decpt = -decpt;
+      *p2++ = '-';
+  }
+  else
+      *p2++ = '+';
+  if (decpt / 100 > 0)
+      *p2++ = decpt / 100 + '0';
+  if (decpt / 10 > 0)
+      *p2++ = (decpt % 100) / 10 + '0';
+  *p2++ = decpt % 10 + '0';
     }
     else {
-	if (decpt <= 0) {
-	    if (*p1 != '0')
-		*p2++ = '.';
-	    while (decpt < 0) {
-		decpt++;
-		*p2++ = '0';
-	    }
-	}
-	for (i = 1; i <= ndigit; i++) {
-	    *p2++ = *p1++;
-	    if (i == decpt)
-		*p2++ = '.';
-	}
-	if (ndigit < decpt) {
-	    while (ndigit++ < decpt)
-		*p2++ = '0';
-	    *p2++ = '.';
-	}
+  if (decpt <= 0) {
+      if (*p1 != '0')
+    *p2++ = '.';
+      while (decpt < 0) {
+    decpt++;
+    *p2++ = '0';
+      }
+  }
+  for (i = 1; i <= ndigit; i++) {
+      *p2++ = *p1++;
+      if (i == decpt)
+    *p2++ = '.';
+  }
+  if (ndigit < decpt) {
+      while (ndigit++ < decpt)
+    *p2++ = '0';
+      *p2++ = '.';
+  }
     }
     if (p2[-1] == '.' && !altform)
-	p2--;
+  p2--;
     *p2 = '\0';
     return (buf);
 }
@@ -254,17 +254,17 @@
  * NOTE: Evaluation of the c argument should not have any side-effects
  */
 #define INS_CHAR(c, sp, bep, cc)				\
-	    {							\
-		if (sp >= bep) {				\
-		    vbuff->curpos = sp;                         \
-		    if (flush_func(vbuff))			\
-			return -1;				\
-		    sp = vbuff->curpos;				\
-		    bep = vbuff->endpos;			\
-		} 						\
-		*sp++ = (c);					\
-		cc++; 						\
-	    }
+      {							\
+    if (sp >= bep) {				\
+        vbuff->curpos = sp;                         \
+        if (flush_func(vbuff))			\
+      return -1;				\
+        sp = vbuff->curpos;				\
+        bep = vbuff->endpos;			\
+    } 						\
+    *sp++ = (c);					\
+    cc++; 						\
+      }
 
 #define NUM( c )			( c - '0' )
 
@@ -272,8 +272,8 @@
     num = NUM( *str++ ) ;		\
     while ( ap_isdigit( *str ) )		\
     {					\
-	num *= 10 ;			\
-	num += NUM( *str++ ) ;		\
+  num *= 10 ;			\
+  num += NUM( *str++ ) ;		\
     }
 
 /*
@@ -289,11 +289,11 @@
 #define FIX_PRECISION( adjust, precision, s, s_len )	\
     if ( adjust ) {					\
         int p = precision < NUM_BUF_SIZE - 1 ? precision : NUM_BUF_SIZE - 1; \
-	while ( s_len < p )				\
-	{						\
-	    *--s = '0' ;				\
-	    s_len++ ;					\
-	}						\
+  while ( s_len < p )				\
+  {						\
+      *--s = '0' ;				\
+      s_len++ ;					\
+  }						\
     }
 
 /*
@@ -301,11 +301,11 @@
  * the character ch.
  */
 #define PAD( width, len, ch )	do		\
-	{					\
-	    INS_CHAR( ch, sp, bep, cc ) ;	\
-	    width-- ;				\
-	}					\
-	while ( width > len )
+  {					\
+      INS_CHAR( ch, sp, bep, cc ) ;	\
+      width-- ;				\
+  }					\
+  while ( width > len )
 
 /*
  * Prefix the character ch to the string str
@@ -332,45 +332,45 @@
  * latter is faster.
  */
 static char *conv_10(register wide_int num, register bool_int is_unsigned,
-		     register bool_int *is_negative, char *buf_end,
-		     register int *len)
+         register bool_int *is_negative, char *buf_end,
+         register int *len)
 {
     register char *p = buf_end;
     register u_wide_int magnitude;
 
     if (is_unsigned) {
-	magnitude = (u_wide_int) num;
-	*is_negative = FALSE;
+  magnitude = (u_wide_int) num;
+  *is_negative = FALSE;
     }
     else {
-	*is_negative = (num < 0);
+  *is_negative = (num < 0);
 
-	/*
-	 * On a 2's complement machine, negating the most negative integer 
-	 * results in a number that cannot be represented as a signed integer.
-	 * Here is what we do to obtain the number's magnitude:
-	 *      a. add 1 to the number
-	 *      b. negate it (becomes positive)
-	 *      c. convert it to unsigned
-	 *      d. add 1
-	 */
-	if (*is_negative) {
-	    wide_int t = num + 1;
-
-	    magnitude = ((u_wide_int) -t) + 1;
-	}
-	else
-	    magnitude = (u_wide_int) num;
+  /*
+   * On a 2's complement machine, negating the most negative integer
+   * results in a number that cannot be represented as a signed integer.
+   * Here is what we do to obtain the number's magnitude:
+   *      a. add 1 to the number
+   *      b. negate it (becomes positive)
+   *      c. convert it to unsigned
+   *      d. add 1
+   */
+  if (*is_negative) {
+      wide_int t = num + 1;
+
+      magnitude = ((u_wide_int) -t) + 1;
+  }
+  else
+      magnitude = (u_wide_int) num;
     }
 
     /*
-     * We use a do-while loop so that we write at least 1 digit 
+     * We use a do-while loop so that we write at least 1 digit
      */
     do {
-	register u_wide_int new_magnitude = magnitude / 10;
+  register u_wide_int new_magnitude = magnitude / 10;
 
-	*--p = (char) (magnitude - new_magnitude * 10 + '0');
-	magnitude = new_magnitude;
+  *--p = (char) (magnitude - new_magnitude * 10 + '0');
+  magnitude = new_magnitude;
     }
     while (magnitude);
 
@@ -379,8 +379,8 @@
 }
 
 static char *conv_10_quad(widest_int num, register bool_int is_unsigned,
-		     register bool_int *is_negative, char *buf_end,
-		     register int *len)
+         register bool_int *is_negative, char *buf_end,
+         register int *len)
 {
     register char *p = buf_end;
     u_widest_int magnitude;
@@ -391,42 +391,42 @@
      * punt to the quicker version.
      */
     if ((num <= ULONG_MAX && is_unsigned) || (num <= LONG_MAX && !is_unsigned))
-    	return(conv_10( (wide_int)num, is_unsigned, is_negative,
-	       buf_end, len));
+      return(conv_10( (wide_int)num, is_unsigned, is_negative,
+         buf_end, len));
 
     if (is_unsigned) {
-	magnitude = (u_widest_int) num;
-	*is_negative = FALSE;
+  magnitude = (u_widest_int) num;
+  *is_negative = FALSE;
     }
     else {
-	*is_negative = (num < 0);
+  *is_negative = (num < 0);
 
-	/*
-	 * On a 2's complement machine, negating the most negative integer 
-	 * results in a number that cannot be represented as a signed integer.
-	 * Here is what we do to obtain the number's magnitude:
-	 *      a. add 1 to the number
-	 *      b. negate it (becomes positive)
-	 *      c. convert it to unsigned
-	 *      d. add 1
-	 */
-	if (*is_negative) {
-	    widest_int t = num + 1;
-
-	    magnitude = ((u_widest_int) -t) + 1;
-	}
-	else
-	    magnitude = (u_widest_int) num;
+  /*
+   * On a 2's complement machine, negating the most negative integer
+   * results in a number that cannot be represented as a signed integer.
+   * Here is what we do to obtain the number's magnitude:
+   *      a. add 1 to the number
+   *      b. negate it (becomes positive)
+   *      c. convert it to unsigned
+   *      d. add 1
+   */
+  if (*is_negative) {
+      widest_int t = num + 1;
+
+      magnitude = ((u_widest_int) -t) + 1;
+  }
+  else
+      magnitude = (u_widest_int) num;
     }
 
     /*
-     * We use a do-while loop so that we write at least 1 digit 
+     * We use a do-while loop so that we write at least 1 digit
      */
     do {
-	u_widest_int new_magnitude = magnitude / 10;
+  u_widest_int new_magnitude = magnitude / 10;
 
-	*--p = (char) (magnitude - new_magnitude * 10 + '0');
-	magnitude = new_magnitude;
+  *--p = (char) (magnitude - new_magnitude * 10 + '0');
+  magnitude = new_magnitude;
     }
     while (magnitude);
 
@@ -490,74 +490,74 @@
     char buf1[NDIG];
 
     if (format == 'f')
-	p = ap_fcvt(num, precision, &decimal_point, is_negative, buf1);
+  p = ap_fcvt(num, precision, &decimal_point, is_negative, buf1);
     else			/* either e or E format */
-	p = ap_ecvt(num, precision + 1, &decimal_point, is_negative, buf1);
+  p = ap_ecvt(num, precision + 1, &decimal_point, is_negative, buf1);
 
     /*
      * Check for Infinity and NaN
      */
     if (ap_isalpha(*p)) {
-	*len = strlen(strcpy(buf, p));
-	*is_negative = FALSE;
-	return (buf);
+  *len = strlen(strcpy(buf, p));
+  *is_negative = FALSE;
+  return (buf);
     }
 
     if (format == 'f') {
-	if (decimal_point <= 0) {
-	    *s++ = '0';
-	    if (precision > 0) {
-		*s++ = '.';
-		while (decimal_point++ < 0)
-		    *s++ = '0';
-	    }
-	    else if (add_dp)
-		*s++ = '.';
-	}
-	else {
-	    while (decimal_point-- > 0)
-		*s++ = *p++;
-	    if (precision > 0 || add_dp)
-		*s++ = '.';
-	}
+  if (decimal_point <= 0) {
+      *s++ = '0';
+      if (precision > 0) {
+    *s++ = '.';
+    while (decimal_point++ < 0)
+        *s++ = '0';
+      }
+      else if (add_dp)
+    *s++ = '.';
+  }
+  else {
+      while (decimal_point-- > 0)
+    *s++ = *p++;
+      if (precision > 0 || add_dp)
+    *s++ = '.';
+  }
     }
     else {
-	*s++ = *p++;
-	if (precision > 0 || add_dp)
-	    *s++ = '.';
+  *s++ = *p++;
+  if (precision > 0 || add_dp)
+      *s++ = '.';
     }
 
     /*
      * copy the rest of p, the NUL is NOT copied
      */
     while (*p)
-	*s++ = *p++;
+  *s++ = *p++;
 
     if (format != 'f') {
-	char temp[EXPONENT_LENGTH];	/* for exponent conversion */
-	int t_len;
-	bool_int exponent_is_negative;
-
-	*s++ = format;		/* either e or E */
-	decimal_point--;
-	if (decimal_point != 0) {
-	    p = conv_10((wide_int) decimal_point, FALSE, &exponent_is_negative,
-			&temp[EXPONENT_LENGTH], &t_len);
-	    *s++ = exponent_is_negative ? '-' : '+';
-
-	    /*
-	     * Make sure the exponent has at least 2 digits
-	     */
-	    if (t_len == 1)
-		*s++ = '0';
-	    while (t_len--)
-		*s++ = *p++;
-	}
-	else {
-	    *s++ = '+';
-	    *s++ = '0';
-	    *s++ = '0';
-	}
+  char temp[EXPONENT_LENGTH];	/* for exponent conversion */
+  int t_len;
+  bool_int exponent_is_negative;
+
+  *s++ = format;		/* either e or E */
+  decimal_point--;
+  if (decimal_point != 0) {
+      p = conv_10((wide_int) decimal_point, FALSE, &exponent_is_negative,
+      &temp[EXPONENT_LENGTH], &t_len);
+      *s++ = exponent_is_negative ? '-' : '+';
+
+      /*
+       * Make sure the exponent has at least 2 digits
+       */
+      if (t_len == 1)
+    *s++ = '0';
+      while (t_len--)
+    *s++ = *p++;
+  }
+  else {
+      *s++ = '+';
+      *s++ = '0';
+      *s++ = '0';
+  }
     }
 
     *len = s - buf;
@@ -579,7 +579,7 @@
  * the number isn't quad size.
  */
 static char *conv_p2(register u_wide_int num, register int nbits,
-		     char format, char *buf_end, register int *len)
+         char format, char *buf_end, register int *len)
 {
     register int mask = (1 << nbits) - 1;
     register char *p = buf_end;
@@ -588,8 +588,8 @@
     register const char *digits = (format == 'X') ? upper_digits : low_digits;
 
     do {
-	*--p = digits[num & mask];
-	num >>= nbits;
+  *--p = digits[num & mask];
+  num >>= nbits;
     }
     while (num);
 
@@ -598,7 +598,7 @@
 }
 
 static char *conv_p2_quad(u_widest_int num, register int nbits,
-		     char format, char *buf_end, register int *len)
+         char format, char *buf_end, register int *len)
 {
     register int mask = (1 << nbits) - 1;
     register char *p = buf_end;
@@ -607,11 +607,11 @@
     register const char *digits = (format == 'X') ? upper_digits : low_digits;
 
     if (num <= ULONG_MAX)
-    	return(conv_p2( (u_wide_int)num, nbits, format, buf_end, len));
+      return(conv_p2( (u_wide_int)num, nbits, format, buf_end, len));
 
     do {
-	*--p = digits[num & mask];
-	num >>= nbits;
+  *--p = digits[num & mask];
+  num >>= nbits;
     }
     while (num);
 
@@ -638,7 +638,7 @@
     register int min_width = 0;
     int precision = 0;
     enum {
-	LEFT, RIGHT
+  LEFT, RIGHT
     } adjust;
     char pad_char;
     char prefix_char;
@@ -653,7 +653,7 @@
     char char_buf[2];		/* for printing %% and %<unknown> */
 
     enum var_type_enum {
-    	IS_QUAD, IS_LONG, IS_SHORT, IS_INT
+      IS_QUAD, IS_LONG, IS_SHORT, IS_INT
     };
     enum var_type_enum var_type = IS_INT;
 
@@ -671,459 +671,459 @@
     bep = vbuff->endpos;
 
     while (*fmt) {
-	if (*fmt != '%') {
-	    INS_CHAR(*fmt, sp, bep, cc);
-	}
-	else {
-	    /*
-	     * Default variable settings
-	     */
-	    adjust = RIGHT;
-	    alternate_form = print_sign = print_blank = NO;
-	    pad_char = ' ';
-	    prefix_char = NUL;
-
-	    fmt++;
-
-	    /*
-	     * Try to avoid checking for flags, width or precision
-	     */
-	    if (!ap_islower(*fmt)) {
-		/*
-		 * Recognize flags: -, #, BLANK, +
-		 */
-		for (;; fmt++) {
-		    if (*fmt == '-')
-			adjust = LEFT;
-		    else if (*fmt == '+')
-			print_sign = YES;
-		    else if (*fmt == '#')
-			alternate_form = YES;
-		    else if (*fmt == ' ')
-			print_blank = YES;
-		    else if (*fmt == '0')
-			pad_char = '0';
-		    else
-			break;
-		}
-
-		/*
-		 * Check if a width was specified
-		 */
-		if (ap_isdigit(*fmt)) {
-		    STR_TO_DEC(fmt, min_width);
-		    adjust_width = YES;
-		}
-		else if (*fmt == '*') {
-		    min_width = va_arg(ap, int);
-		    fmt++;
-		    adjust_width = YES;
-		    if (min_width < 0) {
-			adjust = LEFT;
-			min_width = -min_width;
-		    }
-		}
-		else
-		    adjust_width = NO;
-
-		/*
-		 * Check if a precision was specified
-		 */
-		if (*fmt == '.') {
-		    adjust_precision = YES;
-		    fmt++;
-		    if (ap_isdigit(*fmt)) {
-			STR_TO_DEC(fmt, precision);
-		    }
-		    else if (*fmt == '*') {
-			precision = va_arg(ap, int);
-			fmt++;
-			if (precision < 0)
-			    precision = 0;
-		    }
-		    else
-			precision = 0;
-		}
-		else
-		    adjust_precision = NO;
-	    }
-	    else
-		adjust_precision = adjust_width = NO;
-
-	    /*
-	     * Modifier check
-	     */
-	    if (*fmt == 'q') {
-		var_type = IS_QUAD;
-		fmt++;
-	    }
-	    else if (*fmt == 'l') {
-		var_type = IS_LONG;
-		fmt++;
-	    }
-	    else if (*fmt == 'h') {
-		var_type = IS_SHORT;
-		fmt++;
-	    }
-	    else {
-		var_type = IS_INT;
-	    }
-
-	    /*
-	     * Argument extraction and printing.
-	     * First we determine the argument type.
-	     * Then, we convert the argument to a string.
-	     * On exit from the switch, s points to the string that
-	     * must be printed, s_len has the length of the string
-	     * The precision requirements, if any, are reflected in s_len.
-	     *
-	     * NOTE: pad_char may be set to '0' because of the 0 flag.
-	     *   It is reset to ' ' by non-numeric formats
-	     */
-	    switch (*fmt) {
-	    case 'u':
-	    	if (var_type == IS_QUAD) {
-		    i_quad = va_arg(ap, u_widest_int);
-		    s = conv_10_quad(i_quad, 1, &is_negative,
-			    &num_buf[NUM_BUF_SIZE], &s_len);
-		}
-		else {
-		    if (var_type == IS_LONG)
-			i_num = (wide_int) va_arg(ap, u_wide_int);
-		    else if (var_type == IS_SHORT)
-			i_num = (wide_int) (unsigned short) va_arg(ap, unsigned int);
-		    else
-			i_num = (wide_int) va_arg(ap, unsigned int);
-		    s = conv_10(i_num, 1, &is_negative,
-			    &num_buf[NUM_BUF_SIZE], &s_len);
-		}
-		FIX_PRECISION(adjust_precision, precision, s, s_len);
-		break;
-
-	    case 'd':
-	    case 'i':
-	    	if (var_type == IS_QUAD) {
-		    i_quad = va_arg(ap, widest_int);
-		    s = conv_10_quad(i_quad, 0, &is_negative,
-			    &num_buf[NUM_BUF_SIZE], &s_len);
-		}
-		else {
-		    if (var_type == IS_LONG)
-			i_num = (wide_int) va_arg(ap, wide_int);
-		    else if (var_type == IS_SHORT)
-			i_num = (wide_int) (short) va_arg(ap, int);
-		    else
-			i_num = (wide_int) va_arg(ap, int);
-		    s = conv_10(i_num, 0, &is_negative,
-			    &num_buf[NUM_BUF_SIZE], &s_len);
-		}
-		FIX_PRECISION(adjust_precision, precision, s, s_len);
-
-		if (is_negative)
-		    prefix_char = '-';
-		else if (print_sign)
-		    prefix_char = '+';
-		else if (print_blank)
-		    prefix_char = ' ';
-		break;
-
-
-	    case 'o':
-		if (var_type == IS_QUAD) {
-		    ui_quad = va_arg(ap, u_widest_int);
-		    s = conv_p2_quad(ui_quad, 3, *fmt,
-			    &num_buf[NUM_BUF_SIZE], &s_len);
-		}
-		else {
-		    if (var_type == IS_LONG)
-			ui_num = (u_wide_int) va_arg(ap, u_wide_int);
-		    else if (var_type == IS_SHORT)
-			ui_num = (u_wide_int) (unsigned short) va_arg(ap, unsigned int);
-		    else
-			ui_num = (u_wide_int) va_arg(ap, unsigned int);
-		    s = conv_p2(ui_num, 3, *fmt,
-			    &num_buf[NUM_BUF_SIZE], &s_len);
-		}
-		FIX_PRECISION(adjust_precision, precision, s, s_len);
-		if (alternate_form && *s != '0') {
-		    *--s = '0';
-		    s_len++;
-		}
-		break;
-
-
-	    case 'x':
-	    case 'X':
-		if (var_type == IS_QUAD) {
-		    ui_quad = va_arg(ap, u_widest_int);
-		    s = conv_p2_quad(ui_quad, 4, *fmt,
-			    &num_buf[NUM_BUF_SIZE], &s_len);
-		}
-		else {
-		    if (var_type == IS_LONG)
-			ui_num = (u_wide_int) va_arg(ap, u_wide_int);
-		    else if (var_type == IS_SHORT)
-			ui_num = (u_wide_int) (unsigned short) va_arg(ap, unsigned int);
-		    else
-			ui_num = (u_wide_int) va_arg(ap, unsigned int);
-		    s = conv_p2(ui_num, 4, *fmt,
-			    &num_buf[NUM_BUF_SIZE], &s_len);
-		}
-		FIX_PRECISION(adjust_precision, precision, s, s_len);
-		if (alternate_form && i_num != 0) {
-		    *--s = *fmt;	/* 'x' or 'X' */
-		    *--s = '0';
-		    s_len += 2;
-		}
-		break;
-
-
-	    case 's':
-		s = va_arg(ap, char *);
-		if (s != NULL) {
-		    s_len = strlen(s);
-		    if (adjust_precision && precision < s_len)
-			s_len = precision;
-		}
-		else {
-		    s = S_NULL;
-		    s_len = S_NULL_LEN;
-		}
-		pad_char = ' ';
-		break;
-
-
-	    case 'f':
-	    case 'e':
-	    case 'E':
-		fp_num = va_arg(ap, double);
-		/*
-		 * * We use &num_buf[ 1 ], so that we have room for the sign
-		 */
+  if (*fmt != '%') {
+      INS_CHAR(*fmt, sp, bep, cc);
+  }
+  else {
+      /*
+       * Default variable settings
+       */
+      adjust = RIGHT;
+      alternate_form = print_sign = print_blank = NO;
+      pad_char = ' ';
+      prefix_char = NUL;
+
+      fmt++;
+
+      /*
+       * Try to avoid checking for flags, width or precision
+       */
+      if (!ap_islower(*fmt)) {
+    /*
+     * Recognize flags: -, #, BLANK, +
+     */
+    for (;; fmt++) {
+        if (*fmt == '-')
+      adjust = LEFT;
+        else if (*fmt == '+')
+      print_sign = YES;
+        else if (*fmt == '#')
+      alternate_form = YES;
+        else if (*fmt == ' ')
+      print_blank = YES;
+        else if (*fmt == '0')
+      pad_char = '0';
+        else
+      break;
+    }
+
+    /*
+     * Check if a width was specified
+     */
+    if (ap_isdigit(*fmt)) {
+        STR_TO_DEC(fmt, min_width);
+        adjust_width = YES;
+    }
+    else if (*fmt == '*') {
+        min_width = va_arg(ap, int);
+        fmt++;
+        adjust_width = YES;
+        if (min_width < 0) {
+      adjust = LEFT;
+      min_width = -min_width;
+        }
+    }
+    else
+        adjust_width = NO;
+
+    /*
+     * Check if a precision was specified
+     */
+    if (*fmt == '.') {
+        adjust_precision = YES;
+        fmt++;
+        if (ap_isdigit(*fmt)) {
+      STR_TO_DEC(fmt, precision);
+        }
+        else if (*fmt == '*') {
+      precision = va_arg(ap, int);
+      fmt++;
+      if (precision < 0)
+          precision = 0;
+        }
+        else
+      precision = 0;
+    }
+    else
+        adjust_precision = NO;
+      }
+      else
+    adjust_precision = adjust_width = NO;
+
+      /*
+       * Modifier check
+       */
+      if (*fmt == 'q') {
+    var_type = IS_QUAD;
+    fmt++;
+      }
+      else if (*fmt == 'l') {
+    var_type = IS_LONG;
+    fmt++;
+      }
+      else if (*fmt == 'h') {
+    var_type = IS_SHORT;
+    fmt++;
+      }
+      else {
+    var_type = IS_INT;
+      }
+
+      /*
+       * Argument extraction and printing.
+       * First we determine the argument type.
+       * Then, we convert the argument to a string.
+       * On exit from the switch, s points to the string that
+       * must be printed, s_len has the length of the string
+       * The precision requirements, if any, are reflected in s_len.
+       *
+       * NOTE: pad_char may be set to '0' because of the 0 flag.
+       *   It is reset to ' ' by non-numeric formats
+       */
+      switch (*fmt) {
+      case 'u':
+        if (var_type == IS_QUAD) {
+        i_quad = va_arg(ap, u_widest_int);
+        s = conv_10_quad(i_quad, 1, &is_negative,
+          &num_buf[NUM_BUF_SIZE], &s_len);
+    }
+    else {
+        if (var_type == IS_LONG)
+      i_num = (wide_int) va_arg(ap, u_wide_int);
+        else if (var_type == IS_SHORT)
+      i_num = (wide_int) (unsigned short) va_arg(ap, unsigned int);
+        else
+      i_num = (wide_int) va_arg(ap, unsigned int);
+        s = conv_10(i_num, 1, &is_negative,
+          &num_buf[NUM_BUF_SIZE], &s_len);
+    }
+    FIX_PRECISION(adjust_precision, precision, s, s_len);
+    break;
+
+      case 'd':
+      case 'i':
+        if (var_type == IS_QUAD) {
+        i_quad = va_arg(ap, widest_int);
+        s = conv_10_quad(i_quad, 0, &is_negative,
+          &num_buf[NUM_BUF_SIZE], &s_len);
+    }
+    else {
+        if (var_type == IS_LONG)
+      i_num = (wide_int) va_arg(ap, wide_int);
+        else if (var_type == IS_SHORT)
+      i_num = (wide_int) (short) va_arg(ap, int);
+        else
+      i_num = (wide_int) va_arg(ap, int);
+        s = conv_10(i_num, 0, &is_negative,
+          &num_buf[NUM_BUF_SIZE], &s_len);
+    }
+    FIX_PRECISION(adjust_precision, precision, s, s_len);
+
+    if (is_negative)
+        prefix_char = '-';
+    else if (print_sign)
+        prefix_char = '+';
+    else if (print_blank)
+        prefix_char = ' ';
+    break;
+
+
+      case 'o':
+    if (var_type == IS_QUAD) {
+        ui_quad = va_arg(ap, u_widest_int);
+        s = conv_p2_quad(ui_quad, 3, *fmt,
+          &num_buf[NUM_BUF_SIZE], &s_len);
+    }
+    else {
+        if (var_type == IS_LONG)
+      ui_num = (u_wide_int) va_arg(ap, u_wide_int);
+        else if (var_type == IS_SHORT)
+      ui_num = (u_wide_int) (unsigned short) va_arg(ap, unsigned int);
+        else
+      ui_num = (u_wide_int) va_arg(ap, unsigned int);
+        s = conv_p2(ui_num, 3, *fmt,
+          &num_buf[NUM_BUF_SIZE], &s_len);
+    }
+    FIX_PRECISION(adjust_precision, precision, s, s_len);
+    if (alternate_form && *s != '0') {
+        *--s = '0';
+        s_len++;
+    }
+    break;
+
+
+      case 'x':
+      case 'X':
+    if (var_type == IS_QUAD) {
+        ui_quad = va_arg(ap, u_widest_int);
+        s = conv_p2_quad(ui_quad, 4, *fmt,
+          &num_buf[NUM_BUF_SIZE], &s_len);
+    }
+    else {
+        if (var_type == IS_LONG)
+      ui_num = (u_wide_int) va_arg(ap, u_wide_int);
+        else if (var_type == IS_SHORT)
+      ui_num = (u_wide_int) (unsigned short) va_arg(ap, unsigned int);
+        else
+      ui_num = (u_wide_int) va_arg(ap, unsigned int);
+        s = conv_p2(ui_num, 4, *fmt,
+          &num_buf[NUM_BUF_SIZE], &s_len);
+    }
+    FIX_PRECISION(adjust_precision, precision, s, s_len);
+    if (alternate_form && i_num != 0) {
+        *--s = *fmt;	/* 'x' or 'X' */
+        *--s = '0';
+        s_len += 2;
+    }
+    break;
+
+
+      case 's':
+    s = va_arg(ap, char *);
+    if (s != NULL) {
+        s_len = strlen(s);
+        if (adjust_precision && precision < s_len)
+      s_len = precision;
+    }
+    else {
+        s = S_NULL;
+        s_len = S_NULL_LEN;
+    }
+    pad_char = ' ';
+    break;
+
+
+      case 'f':
+      case 'e':
+      case 'E':
+    fp_num = va_arg(ap, double);
+    /*
+     * * We use &num_buf[ 1 ], so that we have room for the sign
+     */
 #ifdef HAVE_ISNAN
-		if (isnan(fp_num)) {
-		    s = "nan";
-		    s_len = 3;
-		}
-		else
+    if (isnan(fp_num)) {
+        s = "nan";
+        s_len = 3;
+    }
+    else
 #endif
 #ifdef HAVE_ISINF
-		if (isinf(fp_num)) {
-		    s = "inf";
-		    s_len = 3;
-		}
-		else
+    if (isinf(fp_num)) {
+        s = "inf";
+        s_len = 3;
+    }
+    else
 #endif
-		{
-		    s = conv_fp(*fmt, fp_num, alternate_form,
-			    (adjust_precision == NO) ? FLOAT_DIGITS : precision,
-				&is_negative, &num_buf[1], &s_len);
-		    if (is_negative)
-			prefix_char = '-';
-		    else if (print_sign)
-			prefix_char = '+';
-		    else if (print_blank)
-			prefix_char = ' ';
-		}
-	        break;
-
-
-	    case 'g':
-	    case 'G':
-		if (adjust_precision == NO)
-		    precision = FLOAT_DIGITS;
-		else if (precision == 0)
-		    precision = 1;
-		/*
-		 * * We use &num_buf[ 1 ], so that we have room for the sign
-		 */
-		s = ap_gcvt(va_arg(ap, double), precision, &num_buf[1],
-		            alternate_form);
-		if (*s == '-')
-		    prefix_char = *s++;
-		else if (print_sign)
-		    prefix_char = '+';
-		else if (print_blank)
-		    prefix_char = ' ';
-
-		s_len = strlen(s);
-
-		if (alternate_form && (q = strchr(s, '.')) == NULL) {
-		    s[s_len++] = '.';
-		    s[s_len] = '\0'; /* delimit for following strchr() */
-		}
-		if (*fmt == 'G' && (q = strchr(s, 'e')) != NULL)
-		    *q = 'E';
-		break;
-
-
-	    case 'c':
-		char_buf[0] = (char) (va_arg(ap, int));
-		s = &char_buf[0];
-		s_len = 1;
-		pad_char = ' ';
-		break;
-
-
-	    case '%':
-		char_buf[0] = '%';
-		s = &char_buf[0];
-		s_len = 1;
-		pad_char = ' ';
-		break;
-
-
-	    case 'n':
-	    	if (var_type == IS_QUAD)
-		    *(va_arg(ap, widest_int *)) = cc;
-		else if (var_type == IS_LONG)
-		    *(va_arg(ap, long *)) = cc;
-		else if (var_type == IS_SHORT)
-		    *(va_arg(ap, short *)) = cc;
-		else
-		    *(va_arg(ap, int *)) = cc;
-		break;
-
-		/*
-		 * This is where we extend the printf format, with a second
-		 * type specifier
-		 */
-	    case 'p':
-		switch(*++fmt) {
-		    /*
-		     * If the pointer size is equal to or smaller than the size
-		     * of the largest unsigned int, we convert the pointer to a
-		     * hex number, otherwise we print "%p" to indicate that we
-		     * don't handle "%p".
-		     */
-		case 'p':
+    {
+        s = conv_fp(*fmt, fp_num, alternate_form,
+          (adjust_precision == NO) ? FLOAT_DIGITS : precision,
+        &is_negative, &num_buf[1], &s_len);
+        if (is_negative)
+      prefix_char = '-';
+        else if (print_sign)
+      prefix_char = '+';
+        else if (print_blank)
+      prefix_char = ' ';
+    }
+          break;
+
+
+      case 'g':
+      case 'G':
+    if (adjust_precision == NO)
+        precision = FLOAT_DIGITS;
+    else if (precision == 0)
+        precision = 1;
+    /*
+     * * We use &num_buf[ 1 ], so that we have room for the sign
+     */
+    s = ap_gcvt(va_arg(ap, double), precision, &num_buf[1],
+                alternate_form);
+    if (*s == '-')
+        prefix_char = *s++;
+    else if (print_sign)
+        prefix_char = '+';
+    else if (print_blank)
+        prefix_char = ' ';
+
+    s_len = strlen(s);
+
+    if (alternate_form && (q = strchr(s, '.')) == NULL) {
+        s[s_len++] = '.';
+        s[s_len] = '\0'; /* delimit for following strchr() */
+    }
+    if (*fmt == 'G' && (q = strchr(s, 'e')) != NULL)
+        *q = 'E';
+    break;
+
+
+      case 'c':
+    char_buf[0] = (char) (va_arg(ap, int));
+    s = &char_buf[0];
+    s_len = 1;
+    pad_char = ' ';
+    break;
+
+
+      case '%':
+    char_buf[0] = '%';
+    s = &char_buf[0];
+    s_len = 1;
+    pad_char = ' ';
+    break;
+
+
+      case 'n':
+        if (var_type == IS_QUAD)
+        *(va_arg(ap, widest_int *)) = cc;
+    else if (var_type == IS_LONG)
+        *(va_arg(ap, long *)) = cc;
+    else if (var_type == IS_SHORT)
+        *(va_arg(ap, short *)) = cc;
+    else
+        *(va_arg(ap, int *)) = cc;
+    break;
+
+    /*
+     * This is where we extend the printf format, with a second
+     * type specifier
+     */
+      case 'p':
+    switch(*++fmt) {
+        /*
+         * If the pointer size is equal to or smaller than the size
+         * of the largest unsigned int, we convert the pointer to a
+         * hex number, otherwise we print "%p" to indicate that we
+         * don't handle "%p".
+         */
+    case 'p':
 #ifdef AP_VOID_P_IS_QUAD
-		    if (sizeof(void *) <= sizeof(u_widest_int)) {
-		    	ui_quad = (u_widest_int) va_arg(ap, void *);
-			s = conv_p2_quad(ui_quad, 4, 'x',
-				&num_buf[NUM_BUF_SIZE], &s_len);
-		    }
+        if (sizeof(void *) <= sizeof(u_widest_int)) {
+          ui_quad = (u_widest_int) va_arg(ap, void *);
+      s = conv_p2_quad(ui_quad, 4, 'x',
+        &num_buf[NUM_BUF_SIZE], &s_len);
+        }
 #else
-		    if (sizeof(void *) <= sizeof(u_wide_int)) {
-		    	ui_num = (u_wide_int) va_arg(ap, void *);
-			s = conv_p2(ui_num, 4, 'x',
-				&num_buf[NUM_BUF_SIZE], &s_len);
-		    }
+        if (sizeof(void *) <= sizeof(u_wide_int)) {
+          ui_num = (u_wide_int) va_arg(ap, void *);
+      s = conv_p2(ui_num, 4, 'x',
+        &num_buf[NUM_BUF_SIZE], &s_len);
+        }
 #endif
-		    else {
-			s = "%p";
-			s_len = 2;
-			prefix_char = NUL;
-		    }
-		    pad_char = ' ';
-		    break;
+        else {
+      s = "%p";
+      s_len = 2;
+      prefix_char = NUL;
+        }
+        pad_char = ' ';
+        break;
 
 #ifndef BUILD_STANDALONE
-		    /* print a struct sockaddr_in as a.b.c.d:port */
-		case 'I':
-		    {
-			struct sockaddr_in *si;
-
-			si = va_arg(ap, struct sockaddr_in *);
-			if (si != NULL) {
-			    s = conv_sockaddr_in(si, &num_buf[NUM_BUF_SIZE], &s_len);
-			    if (adjust_precision && precision < s_len)
-				s_len = precision;
-			}
-			else {
-			    s = S_NULL;
-			    s_len = S_NULL_LEN;
-			}
-			pad_char = ' ';
-		    }
-		    break;
-
-		    /* print a struct in_addr as a.b.c.d */
-		case 'A':
-		    {
-			struct in_addr *ia;
-
-			ia = va_arg(ap, struct in_addr *);
-			if (ia != NULL) {
-			    s = conv_in_addr(ia, &num_buf[NUM_BUF_SIZE], &s_len);
-			    if (adjust_precision && precision < s_len)
-				s_len = precision;
-			}
-			else {
-			    s = S_NULL;
-			    s_len = S_NULL_LEN;
-			}
-			pad_char = ' ';
-		    }
-		    break;
+        /* print a struct sockaddr_in as a.b.c.d:port */
+    case 'I':
+        {
+      struct sockaddr_in *si;
+
+      si = va_arg(ap, struct sockaddr_in *);
+      if (si != NULL) {
+          s = conv_sockaddr_in(si, &num_buf[NUM_BUF_SIZE], &s_len);
+          if (adjust_precision && precision < s_len)
+        s_len = precision;
+      }
+      else {
+          s = S_NULL;
+          s_len = S_NULL_LEN;
+      }
+      pad_char = ' ';
+        }
+        break;
+
+        /* print a struct in_addr as a.b.c.d */
+    case 'A':
+        {
+      struct in_addr *ia;
+
+      ia = va_arg(ap, struct in_addr *);
+      if (ia != NULL) {
+          s = conv_in_addr(ia, &num_buf[NUM_BUF_SIZE], &s_len);
+          if (adjust_precision && precision < s_len)
+        s_len = precision;
+      }
+      else {
+          s = S_NULL;
+          s_len = S_NULL_LEN;
+      }
+      pad_char = ' ';
+        }
+        break;
 #endif
 
-		case NUL:
-		    /* if %p ends the string, oh well ignore it */
-		    continue;
-
-		default:
-		    s = "bogus %p";
-		    s_len = 8;
-		    prefix_char = NUL;
-		    break;
-		}
-		break;
-
-	    case NUL:
-		/*
-		 * The last character of the format string was %.
-		 * We ignore it.
-		 */
-		continue;
-
-
-		/*
-		 * The default case is for unrecognized %'s.
-		 * We print %<char> to help the user identify what
-		 * option is not understood.
-		 * This is also useful in case the user wants to pass
-		 * the output of format_converter to another function
-		 * that understands some other %<char> (like syslog).
-		 * Note that we can't point s inside fmt because the
-		 * unknown <char> could be preceded by width etc.
-		 */
-	    default:
-		char_buf[0] = '%';
-		char_buf[1] = *fmt;
-		s = char_buf;
-		s_len = 2;
-		pad_char = ' ';
-		break;
-	    }
-
-	    if (prefix_char != NUL && s != S_NULL && s != char_buf) {
-		*--s = prefix_char;
-		s_len++;
-	    }
-
-	    if (adjust_width && adjust == RIGHT && min_width > s_len) {
-		if (pad_char == '0' && prefix_char != NUL) {
-		    INS_CHAR(*s, sp, bep, cc);
-		    s++;
-		    s_len--;
-		    min_width--;
-		}
-		PAD(min_width, s_len, pad_char);
-	    }
-
-	    /*
-	     * Print the string s. 
-	     */
-	    for (i = s_len; i != 0; i--) {
-		INS_CHAR(*s, sp, bep, cc);
-		s++;
-	    }
-
-	    if (adjust_width && adjust == LEFT && min_width > s_len)
-		PAD(min_width, s_len, pad_char);
-	}
-	fmt++;
+    case NUL:
+        /* if %p ends the string, oh well ignore it */
+        continue;
+
+    default:
+        s = "bogus %p";
+        s_len = 8;
+        prefix_char = NUL;
+        break;
+    }
+    break;
+
+      case NUL:
+    /*
+     * The last character of the format string was %.
+     * We ignore it.
+     */
+    continue;
+
+
+    /*
+     * The default case is for unrecognized %'s.
+     * We print %<char> to help the user identify what
+     * option is not understood.
+     * This is also useful in case the user wants to pass
+     * the output of format_converter to another function
+     * that understands some other %<char> (like syslog).
+     * Note that we can't point s inside fmt because the
+     * unknown <char> could be preceded by width etc.
+     */
+      default:
+    char_buf[0] = '%';
+    char_buf[1] = *fmt;
+    s = char_buf;
+    s_len = 2;
+    pad_char = ' ';
+    break;
+      }
+
+      if (prefix_char != NUL && s != S_NULL && s != char_buf) {
+    *--s = prefix_char;
+    s_len++;
+      }
+
+      if (adjust_width && adjust == RIGHT && min_width > s_len) {
+    if (pad_char == '0' && prefix_char != NUL) {
+        INS_CHAR(*s, sp, bep, cc);
+        s++;
+        s_len--;
+        min_width--;
+    }
+    PAD(min_width, s_len, pad_char);
+      }
+
+      /*
+       * Print the string s.
+       */
+      for (i = s_len; i != 0; i--) {
+    INS_CHAR(*s, sp, bep, cc);
+    s++;
+      }
+
+      if (adjust_width && adjust == LEFT && min_width > s_len)
+    PAD(min_width, s_len, pad_char);
+  }
+  fmt++;
     }
     vbuff->curpos = sp;
 
@@ -1147,7 +1147,7 @@
     ap_vformatter_buff vbuff;
 
     if (len == 0)
-	return 0;
+  return 0;
 
     /* save one byte for nul terminator */
     vbuff.curpos = buf;
@@ -1161,13 +1161,13 @@
 
 
 API_EXPORT(int) ap_vsnprintf(char *buf, size_t len, const char *format,
-			     va_list ap)
+           va_list ap)
 {
     int cc;
     ap_vformatter_buff vbuff;
 
     if (len == 0)
-	return 0;
+  return 0;
 
     /* save one byte for nul terminator */
     vbuff.curpos = buf;

Modified: tomcat/connectors/trunk/jk/native/common/ap_snprintf.h
URL: http://svn.apache.org/viewvc/tomcat/connectors/trunk/jk/native/common/ap_snprintf.h?view=diff&rev=532238&r1=532237&r2=532238
==============================================================================
--- tomcat/connectors/trunk/jk/native/common/ap_snprintf.h (original)
+++ tomcat/connectors/trunk/jk/native/common/ap_snprintf.h Wed Apr 25 00:48:37 2007
@@ -138,9 +138,9 @@
  * In no event does ap_snprintf return a negative number.
  */
 API_EXPORT_NONSTD(int) ap_snprintf(char *buf, size_t len, const char *format,...)
-			    __attribute__((format(printf,3,4)));
+          __attribute__((format(printf,3,4)));
 API_EXPORT(int) ap_vsnprintf(char *buf, size_t len, const char *format,
-			     va_list ap);
+           va_list ap);
 
 #ifdef __cplusplus
 }

Modified: tomcat/connectors/trunk/jk/native/common/jk_connect.c
URL: http://svn.apache.org/viewvc/tomcat/connectors/trunk/jk/native/common/jk_connect.c?view=diff&rev=532238&r1=532237&r2=532238
==============================================================================
--- tomcat/connectors/trunk/jk/native/common/jk_connect.c (original)
+++ tomcat/connectors/trunk/jk/native/common/jk_connect.c Wed Apr 25 00:48:37 2007
@@ -230,15 +230,15 @@
  */
 in_addr_t jk_inet_addr(const char * addrstr)
 {
-	in_addr_t addr;
-	char *ptr;
+    in_addr_t addr;
+    char *ptr;
 
-	ptr = (char *)malloc(strlen(addrstr) + 1);
-	jk_ascii2ebcdic((char *)addrstr, ptr);
-	addr = inet_addr(ptr);
-	free(ptr);
+    ptr = (char *)malloc(strlen(addrstr) + 1);
+    jk_ascii2ebcdic((char *)addrstr, ptr);
+    addr = inet_addr(ptr);
+    free(ptr);
 
-	return(addr);
+    return(addr);
 }
 
 #endif

Modified: tomcat/connectors/trunk/jk/native/common/jk_map.c
URL: http://svn.apache.org/viewvc/tomcat/connectors/trunk/jk/native/common/jk_map.c?view=diff&rev=532238&r1=532237&r2=532238
==============================================================================
--- tomcat/connectors/trunk/jk/native/common/jk_map.c (original)
+++ tomcat/connectors/trunk/jk/native/common/jk_map.c Wed Apr 25 00:48:37 2007
@@ -850,7 +850,8 @@
 
     if (m && f) {
         FILE *fp;
-        if (jk_file_exists(f) != JK_TRUE)
+        struct stat statbuf;
+        if (jk_stat(f, &statbuf) != -1)
             return JK_FALSE;
 #if defined(AS400) && !defined(AS400_UTF8)
         fp = fopen(f, "r, o_ccsid=0");
@@ -872,11 +873,8 @@
                 }
             }
             fclose(fp);
-            if (modified) {
-                struct stat statbuf;
-                if (jk_stat(f, &statbuf) != -1)
-                	*modified = statbuf.st_mtime;
-            }
+            if (modified)
+                *modified = statbuf.st_mtime;
         }
     }
 

Modified: tomcat/connectors/trunk/jk/native/common/jk_msg_buff.c
URL: http://svn.apache.org/viewvc/tomcat/connectors/trunk/jk/native/common/jk_msg_buff.c?view=diff&rev=532238&r1=532237&r2=532238
==============================================================================
--- tomcat/connectors/trunk/jk/native/common/jk_msg_buff.c (original)
+++ tomcat/connectors/trunk/jk/native/common/jk_msg_buff.c Wed Apr 25 00:48:37 2007
@@ -344,9 +344,9 @@
 #ifdef USE_CHARSET_EBCDIC
                *current = x;
                jk_xlate_from_ascii(current, 1);
-			   current++;
+               current++;
 #else
-            	*current++ = x;
+              *current++ = x;
 #endif
             }
             else {

Modified: tomcat/connectors/trunk/jk/native/common/jk_util.c
URL: http://svn.apache.org/viewvc/tomcat/connectors/trunk/jk/native/common/jk_util.c?view=diff&rev=532238&r1=532237&r2=532238
==============================================================================
--- tomcat/connectors/trunk/jk/native/common/jk_util.c (original)
+++ tomcat/connectors/trunk/jk/native/common/jk_util.c Wed Apr 25 00:48:37 2007
@@ -1398,15 +1398,15 @@
 
 int jk_stat(const char *f, struct stat * statbuf)
 {
-	char *ptr;
-	int rc;
+  char *ptr;
+  int rc;
 
-	ptr = (char *)malloc(strlen(f) + 1);
-	jk_ascii2ebcdic((char *)f, ptr);
-	rc = stat(ptr, statbuf);
-	free(ptr);
+  ptr = (char *)malloc(strlen(f) + 1);
+  jk_ascii2ebcdic((char *)f, ptr);
+  rc = stat(ptr, statbuf);
+  free(ptr);
 
-	return (rc);
+  return (rc);
 }
 
 #endif
@@ -1417,7 +1417,7 @@
         struct stat st;
 
         if ((0 == jk_stat(f, &st)) && (st.st_mode & S_IFREG))
-			return JK_TRUE;
+      return JK_TRUE;
     }
 
     return JK_FALSE;



---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org


Mime
View raw message