From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 4580 invoked by alias); 29 Dec 2003 15:47:55 -0000 Mailing-List: contact libc-hacker-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-hacker-owner@sources.redhat.com Received: (qmail 4564 invoked from network); 29 Dec 2003 15:47:54 -0000 Received: from unknown (HELO sunsite.ms.mff.cuni.cz) (195.113.19.66) by sources.redhat.com with SMTP; 29 Dec 2003 15:47:54 -0000 Received: from sunsite.ms.mff.cuni.cz (sunsite.mff.cuni.cz [127.0.0.1]) by sunsite.ms.mff.cuni.cz (8.12.8/8.12.8) with ESMTP id hBTDfM2c029598; Mon, 29 Dec 2003 14:41:22 +0100 Received: (from jakub@localhost) by sunsite.ms.mff.cuni.cz (8.12.8/8.12.8/Submit) id hBTDfMR4029596; Mon, 29 Dec 2003 14:41:22 +0100 Date: Mon, 29 Dec 2003 15:47:00 -0000 From: Jakub Jelinek To: Ulrich Drepper Cc: Glibc hackers Subject: [PATCH] Small regexec.c fixes Message-ID: <20031229134122.GO12344@sunsite.ms.mff.cuni.cz> Reply-To: Jakub Jelinek Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline User-Agent: Mutt/1.4i X-SW-Source: 2003-12/txt/msg00093.txt.bz2 Hi! 2003-12-29 Jakub Jelinek * posix/regexec.c (re_copy_regs): Revert comment change. Avoid memory leak if realloc fails. (proceed_next_node): Return -2 if re_node_set_insert fails. Return -2 if push_fail_stack fails. (push_fail_stack): Change fs->alloc only after successful realloc. (pop_fail_stack): Formatting. (set_regs): If proceed_next_node returns -2, free eps_via_nodes and fs. (check_arrival_add_next_nodes): Merge identical statements from if branches. --- libc/posix/regexec.c.jj 2003-12-29 15:03:54.000000000 +0100 +++ libc/posix/regexec.c 2003-12-29 15:23:07.000000000 +0100 @@ -453,8 +453,7 @@ re_copy_regs (regs, pmatch, nregs, regs_ /* Have the register data arrays been allocated? */ if (regs_allocated == REGS_UNALLOCATED) - { /* No. So allocate them with malloc. We allocate the arrays - for the start and end in one block. */ + { /* No. So allocate them with malloc. */ regs->start = re_malloc (regoff_t, need_regs); regs->end = re_malloc (regoff_t, need_regs); if (BE (regs->start == NULL, 0) || BE (regs->end == NULL, 0)) @@ -467,10 +466,12 @@ re_copy_regs (regs, pmatch, nregs, regs_ leave it alone. */ if (BE (need_regs > regs->num_regs, 0)) { - regs->start = re_realloc (regs->start, regoff_t, need_regs); - regs->end = re_realloc (regs->end, regoff_t, need_regs); - if (BE (regs->start == NULL, 0) || BE (regs->end == NULL, 0)) + regoff_t *new_start = re_realloc (regs->start, regoff_t, need_regs); + regoff_t *new_end = re_realloc (regs->end, regoff_t, need_regs); + if (BE (new_start == NULL, 0) || BE (new_end == NULL, 0)) return REGS_UNALLOCATED; + regs->start = new_start; + regs->end = new_end; regs->num_regs = need_regs; } } @@ -1133,7 +1134,7 @@ proceed_next_node (preg, nregs, regs, mc int ndest, dest_nodes[2]; err = re_node_set_insert (eps_via_nodes, node); if (BE (err < 0, 0)) - return -1; + return -2; /* Pick up valid destinations. */ for (ndest = 0, i = 0; i < dfa->edests[node].nelem; ++i) { @@ -1149,8 +1150,10 @@ proceed_next_node (preg, nregs, regs, mc /* In order to avoid infinite loop like "(a*)*". */ if (re_node_set_contains (eps_via_nodes, dest_nodes[0])) return dest_nodes[1]; - if (fs != NULL) - push_fail_stack (fs, *pidx, dest_nodes, nregs, regs, eps_via_nodes); + if (fs != NULL + && push_fail_stack (fs, *pidx, dest_nodes, nregs, regs, + eps_via_nodes)) + return -2; return dest_nodes[0]; } else @@ -1220,11 +1223,11 @@ push_fail_stack (fs, str_idx, dests, nre if (fs->num == fs->alloc) { struct re_fail_stack_ent_t *new_array; - fs->alloc *= 2; new_array = realloc (fs->stack, (sizeof (struct re_fail_stack_ent_t) - * fs->alloc)); + * fs->alloc * 2)); if (new_array == NULL) return REG_ESPACE; + fs->alloc *= 2; fs->stack = new_array; } fs->stack[num].idx = str_idx; @@ -1246,7 +1249,7 @@ pop_fail_stack (fs, pidx, nregs, regs, e { int num = --fs->num; assert (num >= 0); - *pidx = fs->stack[num].idx; + *pidx = fs->stack[num].idx; memcpy (regs, fs->stack[num].regs, sizeof (regmatch_t) * nregs); re_node_set_free (eps_via_nodes); re_free (fs->stack[num].regs); @@ -1329,7 +1332,11 @@ set_regs (preg, mctx, nmatch, pmatch, fl if (BE (cur_node < 0, 0)) { if (cur_node == -2) - return REG_ESPACE; + { + re_node_set_free (&eps_via_nodes); + free_fail_stack_return (fs); + return REG_ESPACE; + } if (fs) cur_node = pop_fail_stack (fs, &idx, nmatch, pmatch, &eps_via_nodes); @@ -2911,21 +2918,12 @@ check_arrival_add_next_nodes (preg, dfa, re_node_set_free (&union_set); return err; } - err = re_node_set_insert (&union_set, next_node); - if (BE (err < 0, 0)) - { - re_node_set_free (&union_set); - return REG_ESPACE; - } } - else + err = re_node_set_insert (&union_set, next_node); + if (BE (err < 0, 0)) { - err = re_node_set_insert (&union_set, next_node); - if (BE (err < 0, 0)) - { - re_node_set_free (&union_set); - return REG_ESPACE; - } + re_node_set_free (&union_set); + return REG_ESPACE; } mctx->state_log[next_idx] = re_acquire_state (&err, dfa, &union_set); Jakub