LCOV - differential code coverage report
Current view: top level - src/backend/regex - regc_cvec.c (source / functions) Coverage Total Hit UBC CBC
Current: 380a8b2ea024c33a35e7abc8628e7c4f52f9f9f9 vs db5ed03217b9c238703df8b4b286115d6e940488 Lines: 95.0 % 40 38 2 38
Current Date: 2026-05-29 21:51:00 -0400 Functions: 100.0 % 6 6 6
Baseline: lcov-20260530-034037-baseline Branches: 50.0 % 20 10 10 10
Baseline Date: 2026-05-29 14:39:03 -0700 Line coverage date bins:
Legend: Lines:     hit not hit
Branches: + taken - not taken # not executed
(360..) days: 95.0 % 40 38 2 38
Function coverage date bins:
(360..) days: 100.0 % 6 6 6
Branch coverage date bins:
(360..) days: 50.0 % 20 10 10 10

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : /*
                                  2                 :                :  * Utility functions for handling cvecs
                                  3                 :                :  * This file is #included by regcomp.c.
                                  4                 :                :  *
                                  5                 :                :  * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
                                  6                 :                :  *
                                  7                 :                :  * Development of this software was funded, in part, by Cray Research Inc.,
                                  8                 :                :  * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
                                  9                 :                :  * Corporation, none of whom are responsible for the results.  The author
                                 10                 :                :  * thanks all of them.
                                 11                 :                :  *
                                 12                 :                :  * Redistribution and use in source and binary forms -- with or without
                                 13                 :                :  * modification -- are permitted for any purpose, provided that
                                 14                 :                :  * redistributions in source form retain this entire copyright notice and
                                 15                 :                :  * indicate the origin and nature of any modifications.
                                 16                 :                :  *
                                 17                 :                :  * I'd appreciate being given credit for this package in the documentation
                                 18                 :                :  * of software which uses it, but that is not a requirement.
                                 19                 :                :  *
                                 20                 :                :  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
                                 21                 :                :  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
                                 22                 :                :  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
                                 23                 :                :  * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
                                 24                 :                :  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
                                 25                 :                :  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
                                 26                 :                :  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
                                 27                 :                :  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
                                 28                 :                :  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
                                 29                 :                :  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
                                 30                 :                :  *
                                 31                 :                :  * src/backend/regex/regc_cvec.c
                                 32                 :                :  *
                                 33                 :                :  */
                                 34                 :                : 
                                 35                 :                : /*
                                 36                 :                :  * Notes:
                                 37                 :                :  * Only (selected) functions in _this_ file should treat the chr arrays
                                 38                 :                :  * of a cvec as non-constant.
                                 39                 :                :  */
                                 40                 :                : 
                                 41                 :                : /*
                                 42                 :                :  * newcvec - allocate a new cvec
                                 43                 :                :  *
                                 44                 :                :  * Note: in current usage, nchrs and nranges are never so large that we risk
                                 45                 :                :  * integer overflow in these size calculations, even with 32-bit size_t.
                                 46                 :                :  */
                                 47                 :                : static struct cvec *
 8515 tgl@sss.pgh.pa.us          48                 :CBC        5148 : newcvec(int nchrs,              /* to hold this many chrs... */
                                 49                 :                :         int nranges)            /* ... and this many ranges */
                                 50                 :                : {
 6680                            51                 :           5148 :     size_t      nc = (size_t) nchrs + (size_t) nranges * 2;
                                 52                 :           5148 :     size_t      n = sizeof(struct cvec) + nc * sizeof(chr);
                                 53                 :           5148 :     struct cvec *cv = (struct cvec *) MALLOC(n);
                                 54                 :                : 
 8335 bruce@momjian.us           55         [ -  + ]:           5148 :     if (cv == NULL)
 8335 bruce@momjian.us           56                 :UBC           0 :         return NULL;
 8335 bruce@momjian.us           57                 :CBC        5148 :     cv->chrspace = nchrs;
 6680 tgl@sss.pgh.pa.us          58                 :           5148 :     cv->chrs = (chr *) (((char *) cv) + sizeof(struct cvec));
                                 59                 :           5148 :     cv->ranges = cv->chrs + nchrs;
 8335 bruce@momjian.us           60                 :           5148 :     cv->rangespace = nranges;
                                 61                 :           5148 :     return clearcvec(cv);
                                 62                 :                : }
                                 63                 :                : 
                                 64                 :                : /*
                                 65                 :                :  * clearcvec - clear a possibly-new cvec
                                 66                 :                :  * Returns pointer as convenience.
                                 67                 :                :  */
                                 68                 :                : static struct cvec *
 3265 tgl@sss.pgh.pa.us          69                 :           6533 : clearcvec(struct cvec *cv)
                                 70                 :                : {
 8335 bruce@momjian.us           71         [ -  + ]:           6533 :     assert(cv != NULL);
                                 72                 :           6533 :     cv->nchrs = 0;
                                 73                 :           6533 :     cv->nranges = 0;
 3554 tgl@sss.pgh.pa.us          74                 :           6533 :     cv->cclasscode = -1;
 8335 bruce@momjian.us           75                 :           6533 :     return cv;
                                 76                 :                : }
                                 77                 :                : 
                                 78                 :                : /*
                                 79                 :                :  * addchr - add a chr to a cvec
                                 80                 :                :  */
                                 81                 :                : static void
 3265 tgl@sss.pgh.pa.us          82                 :           2533 : addchr(struct cvec *cv,         /* character vector */
                                 83                 :                :        chr c)                   /* character to add */
                                 84                 :                : {
 5214                            85         [ -  + ]:           2533 :     assert(cv->nchrs < cv->chrspace);
 3571                            86                 :           2533 :     cv->chrs[cv->nchrs++] = c;
 8515                            87                 :           2533 : }
                                 88                 :                : 
                                 89                 :                : /*
                                 90                 :                :  * addrange - add a range to a cvec
                                 91                 :                :  */
                                 92                 :                : static void
 3265                            93                 :            351 : addrange(struct cvec *cv,       /* character vector */
                                 94                 :                :          chr from,              /* first character of range */
                                 95                 :                :          chr to)                /* last character of range */
                                 96                 :                : {
 8335 bruce@momjian.us           97         [ -  + ]:            351 :     assert(cv->nranges < cv->rangespace);
 3571 tgl@sss.pgh.pa.us          98                 :            351 :     cv->ranges[cv->nranges * 2] = from;
                                 99                 :            351 :     cv->ranges[cv->nranges * 2 + 1] = to;
 8335 bruce@momjian.us          100                 :            351 :     cv->nranges++;
 8515 tgl@sss.pgh.pa.us         101                 :            351 : }
                                102                 :                : 
                                103                 :                : /*
                                104                 :                :  * getcvec - get a transient cvec, initialized to empty
                                105                 :                :  *
                                106                 :                :  * The returned cvec is valid only until the next call of getcvec, which
                                107                 :                :  * typically will recycle the space.  Callers should *not* free the cvec
                                108                 :                :  * explicitly; it will be cleaned up when the struct vars is destroyed.
                                109                 :                :  *
                                110                 :                :  * This is typically used while interpreting bracket expressions.  In that
                                111                 :                :  * usage the cvec is only needed momentarily until we build arcs from it,
                                112                 :                :  * so transientness is a convenient behavior.
                                113                 :                :  */
                                114                 :                : static struct cvec *
 3265                           115                 :           1386 : getcvec(struct vars *v,         /* context */
                                116                 :                :         int nchrs,              /* to hold this many chrs... */
                                117                 :                :         int nranges)            /* ... and this many ranges */
                                118                 :                : {
                                119                 :                :     /* recycle existing transient cvec if large enough */
 8335 bruce@momjian.us          120   [ +  -  +  + ]:           1386 :     if (v->cv != NULL && nchrs <= v->cv->chrspace &&
 6680 tgl@sss.pgh.pa.us         121         [ +  - ]:           1385 :         nranges <= v->cv->rangespace)
 8335 bruce@momjian.us          122                 :           1385 :         return clearcvec(v->cv);
                                123                 :                : 
                                124                 :                :     /* nope, make a new one */
                                125         [ +  - ]:              1 :     if (v->cv != NULL)
                                126                 :              1 :         freecvec(v->cv);
 6680 tgl@sss.pgh.pa.us         127                 :              1 :     v->cv = newcvec(nchrs, nranges);
 8335 bruce@momjian.us          128         [ -  + ]:              1 :     if (v->cv == NULL)
 8335 bruce@momjian.us          129         [ #  # ]:UBC           0 :         ERR(REG_ESPACE);
                                130                 :                : 
 8335 bruce@momjian.us          131                 :CBC           1 :     return v->cv;
                                132                 :                : }
                                133                 :                : 
                                134                 :                : /*
                                135                 :                :  * freecvec - free a cvec
                                136                 :                :  */
                                137                 :                : static void
 3265 tgl@sss.pgh.pa.us         138                 :           5148 : freecvec(struct cvec *cv)
                                139                 :                : {
 8335 bruce@momjian.us          140                 :           5148 :     FREE(cv);
 8515 tgl@sss.pgh.pa.us         141                 :           5148 : }
        

Generated by: LCOV version 2.5.0-beta