This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

Another patch for "might be clobbered" warnings (c-lex.c)


	This patch fixes the "might be clobbered" warnings in c-lex.c.

Thankfully, this is the last of the "clobbered" warnings appearing in
the top level directory (at least for my test platforms.  One last
spot occurs in the java dir, I'll address that later.)

	I tested this by bootstrapping on Irix6.  Okay to install?

		Thanks,
		--Kaveh



Tue Mar 16 11:04:19 1999  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>

        * c-lex.c: Don't include setjmp.h.
	(parse_float): New static function.
	(pf_args): New struct.
	(yylex): Use them in call to `do_float_handler'.


*** orig/egcs-CVS19990315/gcc/c-lex.c	Mon Feb 22 16:43:00 1999
--- egcs-CVS19990315/gcc/c-lex.c	Tue Mar 16 11:02:01 1999
*************** Boston, MA 02111-1307, USA.  */
*** 20,26 ****
  
  #include "config.h"
  #include "system.h"
- #include <setjmp.h>
  
  #include "rtl.h"
  #include "tree.h"
--- 20,25 ----
*************** static int skip_white_space		PROTO((int)
*** 126,131 ****
--- 125,131 ----
  static int skip_white_space_on_line	PROTO((void));
  static char *extend_token_buffer	PROTO((const char *));
  static int readescape			PROTO((int *));
+ static void parse_float			PROTO((PTR));
  
  /* Do not insert generated code into the source, instead, include it.
     This allows us to build gcc automatically even for targets that
*************** struct try_type type_sequence[] =
*** 1090,1095 ****
--- 1090,1209 ----
  };
  #endif /* 0 */
  
+ struct pf_args
+ {
+   /* Input */
+   int base;
+   char * p;
+   /* I/O */
+   int c;
+   int imag;
+   tree type;
+   int conversion_errno;
+   /* Output */
+   REAL_VALUE_TYPE value;
+ };
+  
+ static void
+ parse_float (data)
+   PTR data;
+ {
+   struct pf_args * args = (struct pf_args *) data;
+   int fflag = 0, lflag = 0;
+   /* Copy token_buffer now, while it has just the number
+      and not the suffixes; once we add `f' or `i',
+      REAL_VALUE_ATOF may not work any more.  */
+   char *copy = (char *) alloca (args->p - token_buffer + 1);
+   bcopy (token_buffer, copy, args->p - token_buffer + 1);
+ 
+   while (1)
+     {
+       int lose = 0;
+ 
+       /* Read the suffixes to choose a data type.  */
+       switch (args->c)
+ 	{
+ 	case 'f': case 'F':
+ 	  if (fflag)
+ 	    error ("more than one `f' in numeric constant");
+ 	  fflag = 1;
+ 	  break;
+ 
+ 	case 'l': case 'L':
+ 	  if (lflag)
+ 	    error ("more than one `l' in numeric constant");
+ 	  lflag = 1;
+ 	  break;
+ 
+ 	case 'i': case 'I':
+ 	  if (args->imag)
+ 	    error ("more than one `i' or `j' in numeric constant");
+ 	  else if (pedantic)
+ 	    pedwarn ("ANSI C forbids imaginary numeric constants");
+ 	  args->imag = 1;
+ 	  break;
+ 
+ 	default:
+ 	  lose = 1;
+ 	}
+ 
+       if (lose)
+ 	break;
+ 
+       if (args->p >= token_buffer + maxtoken - 3)
+ 	args->p = extend_token_buffer (args->p);
+       *(args->p++) = args->c;
+       *(args->p) = 0;
+       args->c = GETC();
+     }
+ 
+   /* The second argument, machine_mode, of REAL_VALUE_ATOF
+      tells the desired precision of the binary result
+      of decimal-to-binary conversion.  */
+ 
+   if (fflag)
+     {
+       if (lflag)
+ 	error ("both `f' and `l' in floating constant");
+ 
+       args->type = float_type_node;
+       errno = 0;
+       if (args->base == 16)
+ 	args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
+       else
+ 	args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
+       args->conversion_errno = errno;
+       /* A diagnostic is required here by some ANSI C testsuites.
+ 	 This is not pedwarn, because some people don't want
+ 	 an error for this.  */
+       if (REAL_VALUE_ISINF (args->value) && pedantic)
+ 	warning ("floating point number exceeds range of `float'");
+     }
+   else if (lflag)
+     {
+       args->type = long_double_type_node;
+       errno = 0;
+       if (args->base == 16)
+ 	args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
+       else
+ 	args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
+       args->conversion_errno = errno;
+       if (REAL_VALUE_ISINF (args->value) && pedantic)
+ 	warning ("floating point number exceeds range of `long double'");
+     }
+   else
+     {
+       errno = 0;
+       if (args->base == 16)
+ 	args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
+       else
+ 	args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
+       args->conversion_errno = errno;
+       if (REAL_VALUE_ISINF (args->value) && pedantic)
+ 	warning ("floating point number exceeds range of `double'");
+     }
+ }
+  
  int
  yylex ()
  {
*************** yylex ()
*** 1490,1496 ****
  	    int imag = 0;
  	    int conversion_errno = 0;
  	    REAL_VALUE_TYPE value;
! 	    jmp_buf handler;
  
  	    /* Read explicit exponent if any, and put it in tokenbuf.  */
  
--- 1604,1610 ----
  	    int imag = 0;
  	    int conversion_errno = 0;
  	    REAL_VALUE_TYPE value;
! 	    struct pf_args args;
  
  	    /* Read explicit exponent if any, and put it in tokenbuf.  */
  
*************** yylex ()
*** 1522,1633 ****
  
  	    *p = 0;
  
  	    /* Convert string to a double, checking for overflow.  */
! 	    if (setjmp (handler))
  	      {
! 		error ("floating constant out of range");
! 		value = dconst0;
  	      }
  	    else
  	      {
! 		int fflag = 0, lflag = 0;
! 		/* Copy token_buffer now, while it has just the number
! 		   and not the suffixes; once we add `f' or `i',
! 		   REAL_VALUE_ATOF may not work any more.  */
! 		char *copy = (char *) alloca (p - token_buffer + 1);
! 		bcopy (token_buffer, copy, p - token_buffer + 1);
! 
! 		set_float_handler (handler);
! 
! 		while (1)
! 		  {
! 		    int lose = 0;
! 
! 		    /* Read the suffixes to choose a data type.  */
! 		    switch (c)
! 		      {
! 		      case 'f': case 'F':
! 			if (fflag)
! 			  error ("more than one `f' in numeric constant");
! 			fflag = 1;
! 			break;
! 
! 		      case 'l': case 'L':
! 			if (lflag)
! 			  error ("more than one `l' in numeric constant");
! 			lflag = 1;
! 			break;
! 
! 		      case 'i': case 'I':
! 			if (imag)
! 			  error ("more than one `i' or `j' in numeric constant");
! 			else if (pedantic)
! 			  pedwarn ("ANSI C forbids imaginary numeric constants");
! 			imag = 1;
! 			break;
! 
! 		      default:
! 			lose = 1;
! 		      }
! 
! 		    if (lose)
! 		      break;
! 
! 		    if (p >= token_buffer + maxtoken - 3)
! 		      p = extend_token_buffer (p);
! 		    *p++ = c;
! 		    *p = 0;
! 		    c = GETC();
! 		  }
! 
! 		/* The second argument, machine_mode, of REAL_VALUE_ATOF
! 		   tells the desired precision of the binary result
! 		   of decimal-to-binary conversion.  */
! 
! 		if (fflag)
! 		  {
! 		    if (lflag)
! 		      error ("both `f' and `l' in floating constant");
! 
! 		    type = float_type_node;
! 		    errno = 0;
! 		    if (base == 16)
! 		      value = REAL_VALUE_HTOF (copy, TYPE_MODE (type));
! 		    else
! 		      value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
! 		    conversion_errno = errno;
! 		    /* A diagnostic is required here by some ANSI C testsuites.
! 		       This is not pedwarn, because some people don't want
! 		       an error for this.  */
! 		    if (REAL_VALUE_ISINF (value) && pedantic)
! 		      warning ("floating point number exceeds range of `float'");
! 		  }
! 		else if (lflag)
! 		  {
! 		    type = long_double_type_node;
! 		    errno = 0;
! 		    if (base == 16)
! 		      value = REAL_VALUE_HTOF (copy, TYPE_MODE (type));
! 		    else
! 		      value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
! 		    conversion_errno = errno;
! 		    if (REAL_VALUE_ISINF (value) && pedantic)
! 		      warning ("floating point number exceeds range of `long double'");
! 		  }
! 		else
! 		  {
! 		    errno = 0;
! 		    if (base == 16)
! 		      value = REAL_VALUE_HTOF (copy, TYPE_MODE (type));
! 		    else
! 		      value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
! 		    conversion_errno = errno;
! 		    if (REAL_VALUE_ISINF (value) && pedantic)
! 		      warning ("floating point number exceeds range of `double'");
! 		  }
  
! 		set_float_handler (NULL_PTR);
! 	    }
  #ifdef ERANGE
  	    /* ERANGE is also reported for underflow,
  	       so test the value to distinguish overflow from that.  */
--- 1636,1668 ----
  
  	    *p = 0;
  
+ 	    /* Setup input for parse_float() */
+ 	    args.base = base;
+ 	    args.p = p;
+ 	    args.c = c;
+ 	    args.imag = imag;
+ 	    args.type = type;
+ 	    args.conversion_errno = conversion_errno;
+ 
  	    /* Convert string to a double, checking for overflow.  */
! 	    if (do_float_handler (parse_float, (PTR) &args))
  	      {
! 		/* Receive output from parse_float() */
! 		value = args.value;
  	      }
  	    else
  	      {
! 		/* We got an exception from parse_float() */
! 		error ("floating constant out of range");
! 		value = dconst0;
! 	      }
  
! 	    /* Receive output from parse_float() */
! 	    c = args.c;
! 	    imag = args.imag;
! 	    type = args.type;
! 	    conversion_errno = args.conversion_errno;
! 	    
  #ifdef ERANGE
  	    /* ERANGE is also reported for underflow,
  	       so test the value to distinguish overflow from that.  */


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]