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]
Other format: [Raw text]

[patch] libiberty/regex.c: avoid string concatenation


This should fix bootstrap/7170

2002-08-07  DJ Delorie  <dj@redhat.com>

	* regex.c (re_error_msgid): Just use a simple array of strings.
	(re_compile_pattern): Compensate.
	(re_comp): Likewise.
	(re_comp): Likewise.
	(regerror): Likewise.

Index: regex.c
===================================================================
RCS file: /cvs/gcc/gcc/libiberty/regex.c,v
retrieving revision 1.10
diff -p -3 -r1.10 regex.c
*** regex.c	16 Nov 2001 21:54:17 -0000	1.10
--- regex.c	7 Aug 2002 20:47:24 -0000
***************
*** 2,8 ****
     version 0.12.
     (Implements POSIX draft P1003.2/D11.2, except for some of the
     internationalization features.)
!    Copyright (C) 1993-1999, 2000, 2001 Free Software Foundation, Inc.
     This file is part of the GNU C Library.
  
     The GNU C Library is free software; you can redistribute it and/or
--- 2,8 ----
     version 0.12.
     (Implements POSIX draft P1003.2/D11.2, except for some of the
     internationalization features.)
!    Copyright (C) 1993-1999, 2000, 2001, 2002 Free Software Foundation, Inc.
     This file is part of the GNU C Library.
  
     The GNU C Library is free software; you can redistribute it and/or
*************** weak_alias (__re_set_syntax, re_set_synt
*** 1373,1452 ****
     POSIX doesn't require that we do anything for REG_NOERROR,
     but why not be nice?  */
  
! static const char re_error_msgid[] =
    {
! # define REG_NOERROR_IDX	0
!     gettext_noop ("Success")	/* REG_NOERROR */
!     "\0"
! # define REG_NOMATCH_IDX (REG_NOERROR_IDX + sizeof "Success")
!     gettext_noop ("No match")	/* REG_NOMATCH */
!     "\0"
! # define REG_BADPAT_IDX	(REG_NOMATCH_IDX + sizeof "No match")
!     gettext_noop ("Invalid regular expression") /* REG_BADPAT */
!     "\0"
! # define REG_ECOLLATE_IDX (REG_BADPAT_IDX + sizeof "Invalid regular expression")
!     gettext_noop ("Invalid collation character") /* REG_ECOLLATE */
!     "\0"
! # define REG_ECTYPE_IDX	(REG_ECOLLATE_IDX + sizeof "Invalid collation character")
!     gettext_noop ("Invalid character class name") /* REG_ECTYPE */
!     "\0"
! # define REG_EESCAPE_IDX	(REG_ECTYPE_IDX + sizeof "Invalid character class name")
!     gettext_noop ("Trailing backslash") /* REG_EESCAPE */
!     "\0"
! # define REG_ESUBREG_IDX	(REG_EESCAPE_IDX + sizeof "Trailing backslash")
!     gettext_noop ("Invalid back reference") /* REG_ESUBREG */
!     "\0"
! # define REG_EBRACK_IDX	(REG_ESUBREG_IDX + sizeof "Invalid back reference")
!     gettext_noop ("Unmatched [ or [^")	/* REG_EBRACK */
!     "\0"
! # define REG_EPAREN_IDX	(REG_EBRACK_IDX + sizeof "Unmatched [ or [^")
!     gettext_noop ("Unmatched ( or \\(") /* REG_EPAREN */
!     "\0"
! # define REG_EBRACE_IDX	(REG_EPAREN_IDX + sizeof "Unmatched ( or \\(")
!     gettext_noop ("Unmatched \\{") /* REG_EBRACE */
!     "\0"
! # define REG_BADBR_IDX	(REG_EBRACE_IDX + sizeof "Unmatched \\{")
!     gettext_noop ("Invalid content of \\{\\}") /* REG_BADBR */
!     "\0"
! # define REG_ERANGE_IDX	(REG_BADBR_IDX + sizeof "Invalid content of \\{\\}")
!     gettext_noop ("Invalid range end")	/* REG_ERANGE */
!     "\0"
! # define REG_ESPACE_IDX	(REG_ERANGE_IDX + sizeof "Invalid range end")
!     gettext_noop ("Memory exhausted") /* REG_ESPACE */
!     "\0"
! # define REG_BADRPT_IDX	(REG_ESPACE_IDX + sizeof "Memory exhausted")
!     gettext_noop ("Invalid preceding regular expression") /* REG_BADRPT */
!     "\0"
! # define REG_EEND_IDX	(REG_BADRPT_IDX + sizeof "Invalid preceding regular expression")
!     gettext_noop ("Premature end of regular expression") /* REG_EEND */
!     "\0"
! # define REG_ESIZE_IDX	(REG_EEND_IDX + sizeof "Premature end of regular expression")
!     gettext_noop ("Regular expression too big") /* REG_ESIZE */
!     "\0"
! # define REG_ERPAREN_IDX	(REG_ESIZE_IDX + sizeof "Regular expression too big")
      gettext_noop ("Unmatched ) or \\)") /* REG_ERPAREN */
    };
- 
- static const size_t re_error_msgid_idx[] =
-   {
-     REG_NOERROR_IDX,
-     REG_NOMATCH_IDX,
-     REG_BADPAT_IDX,
-     REG_ECOLLATE_IDX,
-     REG_ECTYPE_IDX,
-     REG_EESCAPE_IDX,
-     REG_ESUBREG_IDX,
-     REG_EBRACK_IDX,
-     REG_EPAREN_IDX,
-     REG_EBRACE_IDX,
-     REG_BADBR_IDX,
-     REG_ERANGE_IDX,
-     REG_ESPACE_IDX,
-     REG_BADRPT_IDX,
-     REG_EEND_IDX,
-     REG_ESIZE_IDX,
-     REG_ERPAREN_IDX
-   };
  
  #endif /* INSIDE_RECURSION */
  
--- 1373,1398 ----
     POSIX doesn't require that we do anything for REG_NOERROR,
     but why not be nice?  */
  
! static const char *re_error_msgid[] =
    {
!     gettext_noop ("Success"),	/* REG_NOERROR */
!     gettext_noop ("No match"),	/* REG_NOMATCH */
!     gettext_noop ("Invalid regular expression"), /* REG_BADPAT */
!     gettext_noop ("Invalid collation character"), /* REG_ECOLLATE */
!     gettext_noop ("Invalid character class name"), /* REG_ECTYPE */
!     gettext_noop ("Trailing backslash"), /* REG_EESCAPE */
!     gettext_noop ("Invalid back reference"), /* REG_ESUBREG */
!     gettext_noop ("Unmatched [ or [^"),	/* REG_EBRACK */
!     gettext_noop ("Unmatched ( or \\("), /* REG_EPAREN */
!     gettext_noop ("Unmatched \\{"), /* REG_EBRACE */
!     gettext_noop ("Invalid content of \\{\\}"), /* REG_BADBR */
!     gettext_noop ("Invalid range end"),	/* REG_ERANGE */
!     gettext_noop ("Memory exhausted"), /* REG_ESPACE */
!     gettext_noop ("Invalid preceding regular expression"), /* REG_BADRPT */
!     gettext_noop ("Premature end of regular expression"), /* REG_EEND */
!     gettext_noop ("Regular expression too big"), /* REG_ESIZE */
      gettext_noop ("Unmatched ) or \\)") /* REG_ERPAREN */
    };
  
  #endif /* INSIDE_RECURSION */
  
*************** re_compile_pattern (pattern, length, buf
*** 7944,7950 ****
  
    if (!ret)
      return NULL;
!   return gettext (re_error_msgid + re_error_msgid_idx[(int) ret]);
  }
  #ifdef _LIBC
  weak_alias (__re_compile_pattern, re_compile_pattern)
--- 7890,7896 ----
  
    if (!ret)
      return NULL;
!   return gettext (re_error_msgid[(int) ret]);
  }
  #ifdef _LIBC
  weak_alias (__re_compile_pattern, re_compile_pattern)
*************** re_comp (s)
*** 7981,7994 ****
      {
        re_comp_buf.buffer = (unsigned char *) malloc (200);
        if (re_comp_buf.buffer == NULL)
!         return (char *) gettext (re_error_msgid
! 				 + re_error_msgid_idx[(int) REG_ESPACE]);
        re_comp_buf.allocated = 200;
  
        re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH);
        if (re_comp_buf.fastmap == NULL)
! 	return (char *) gettext (re_error_msgid
! 				 + re_error_msgid_idx[(int) REG_ESPACE]);
      }
  
    /* Since `re_exec' always passes NULL for the `regs' argument, we
--- 7927,7938 ----
      {
        re_comp_buf.buffer = (unsigned char *) malloc (200);
        if (re_comp_buf.buffer == NULL)
!         return (char *) gettext (re_error_msgid[(int) REG_ESPACE]);
        re_comp_buf.allocated = 200;
  
        re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH);
        if (re_comp_buf.fastmap == NULL)
! 	return (char *) gettext (re_error_msgid[(int) REG_ESPACE]);
      }
  
    /* Since `re_exec' always passes NULL for the `regs' argument, we
*************** re_comp (s)
*** 8008,8014 ****
      return NULL;
  
    /* Yes, we're discarding `const' here if !HAVE_LIBINTL.  */
!   return (char *) gettext (re_error_msgid + re_error_msgid_idx[(int) ret]);
  }
  
  
--- 7952,7958 ----
      return NULL;
  
    /* Yes, we're discarding `const' here if !HAVE_LIBINTL.  */
!   return (char *) gettext (re_error_msgid[(int) ret]);
  }
  
  
*************** regerror (errcode, preg, errbuf, errbuf_
*** 8239,8253 ****
    size_t msg_size;
  
    if (errcode < 0
!       || errcode >= (int) (sizeof (re_error_msgid_idx)
! 			   / sizeof (re_error_msgid_idx[0])))
      /* Only error codes returned by the rest of the code should be passed
         to this routine.  If we are given anything else, or if other regex
         code generates an invalid error code, then the program has a bug.
         Dump core so we can fix it.  */
      abort ();
  
!   msg = gettext (re_error_msgid + re_error_msgid_idx[errcode]);
  
    msg_size = strlen (msg) + 1; /* Includes the null.  */
  
--- 8183,8197 ----
    size_t msg_size;
  
    if (errcode < 0
!       || errcode >= (int) (sizeof (re_error_msgid)
! 			   / sizeof (re_error_msgid[0])))
      /* Only error codes returned by the rest of the code should be passed
         to this routine.  If we are given anything else, or if other regex
         code generates an invalid error code, then the program has a bug.
         Dump core so we can fix it.  */
      abort ();
  
!   msg = gettext (re_error_msgid[errcode]);
  
    msg_size = strlen (msg) + 1; /* Includes the null.  */
  


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