LCOV - differential code coverage report
Current view: top level - src/backend/regex - regc_cvec.c (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 95.0 % 40 38 2 38
Current Date: 2024-04-14 14:21:10 Functions: 100.0 % 6 6 6
Baseline: 16@8cea358b128 Branches: 50.0 % 20 10 10 10
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (240..) days: 95.0 % 40 38 2 38
Function coverage date bins:
(240..) days: 100.0 % 6 6 6
Branch coverage date bins:
(240..) 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                 :                : static struct cvec *
 7739 tgl@sss.pgh.pa.us          45                 :CBC        3611 : newcvec(int nchrs,              /* to hold this many chrs... */
                                 46                 :                :         int nranges)            /* ... and this many ranges */
                                 47                 :                : {
 5904                            48                 :           3611 :     size_t      nc = (size_t) nchrs + (size_t) nranges * 2;
                                 49                 :           3611 :     size_t      n = sizeof(struct cvec) + nc * sizeof(chr);
                                 50                 :           3611 :     struct cvec *cv = (struct cvec *) MALLOC(n);
                                 51                 :                : 
 7559 bruce@momjian.us           52         [ -  + ]:           3611 :     if (cv == NULL)
 7559 bruce@momjian.us           53                 :UBC           0 :         return NULL;
 7559 bruce@momjian.us           54                 :CBC        3611 :     cv->chrspace = nchrs;
 5904 tgl@sss.pgh.pa.us          55                 :           3611 :     cv->chrs = (chr *) (((char *) cv) + sizeof(struct cvec));
                                 56                 :           3611 :     cv->ranges = cv->chrs + nchrs;
 7559 bruce@momjian.us           57                 :           3611 :     cv->rangespace = nranges;
                                 58                 :           3611 :     return clearcvec(cv);
                                 59                 :                : }
                                 60                 :                : 
                                 61                 :                : /*
                                 62                 :                :  * clearcvec - clear a possibly-new cvec
                                 63                 :                :  * Returns pointer as convenience.
                                 64                 :                :  */
                                 65                 :                : static struct cvec *
 2489 tgl@sss.pgh.pa.us          66                 :           4748 : clearcvec(struct cvec *cv)
                                 67                 :                : {
 7559 bruce@momjian.us           68         [ -  + ]:           4748 :     assert(cv != NULL);
                                 69                 :           4748 :     cv->nchrs = 0;
                                 70                 :           4748 :     cv->nranges = 0;
 2778 tgl@sss.pgh.pa.us          71                 :           4748 :     cv->cclasscode = -1;
 7559 bruce@momjian.us           72                 :           4748 :     return cv;
                                 73                 :                : }
                                 74                 :                : 
                                 75                 :                : /*
                                 76                 :                :  * addchr - add a chr to a cvec
                                 77                 :                :  */
                                 78                 :                : static void
 2489 tgl@sss.pgh.pa.us          79                 :           2077 : addchr(struct cvec *cv,         /* character vector */
                                 80                 :                :        chr c)                   /* character to add */
                                 81                 :                : {
 4438                            82         [ -  + ]:           2077 :     assert(cv->nchrs < cv->chrspace);
 2795                            83                 :           2077 :     cv->chrs[cv->nchrs++] = c;
 7739                            84                 :           2077 : }
                                 85                 :                : 
                                 86                 :                : /*
                                 87                 :                :  * addrange - add a range to a cvec
                                 88                 :                :  */
                                 89                 :                : static void
 2489                            90                 :            287 : addrange(struct cvec *cv,       /* character vector */
                                 91                 :                :          chr from,              /* first character of range */
                                 92                 :                :          chr to)                /* last character of range */
                                 93                 :                : {
 7559 bruce@momjian.us           94         [ -  + ]:            287 :     assert(cv->nranges < cv->rangespace);
 2795 tgl@sss.pgh.pa.us          95                 :            287 :     cv->ranges[cv->nranges * 2] = from;
                                 96                 :            287 :     cv->ranges[cv->nranges * 2 + 1] = to;
 7559 bruce@momjian.us           97                 :            287 :     cv->nranges++;
 7739 tgl@sss.pgh.pa.us          98                 :            287 : }
                                 99                 :                : 
                                100                 :                : /*
                                101                 :                :  * getcvec - get a transient cvec, initialized to empty
                                102                 :                :  *
                                103                 :                :  * The returned cvec is valid only until the next call of getcvec, which
                                104                 :                :  * typically will recycle the space.  Callers should *not* free the cvec
                                105                 :                :  * explicitly; it will be cleaned up when the struct vars is destroyed.
                                106                 :                :  *
                                107                 :                :  * This is typically used while interpreting bracket expressions.  In that
                                108                 :                :  * usage the cvec is only needed momentarily until we build arcs from it,
                                109                 :                :  * so transientness is a convenient behavior.
                                110                 :                :  */
                                111                 :                : static struct cvec *
 2489                           112                 :           1138 : getcvec(struct vars *v,         /* context */
                                113                 :                :         int nchrs,              /* to hold this many chrs... */
                                114                 :                :         int nranges)            /* ... and this many ranges */
                                115                 :                : {
                                116                 :                :     /* recycle existing transient cvec if large enough */
 7559 bruce@momjian.us          117   [ +  -  +  + ]:           1138 :     if (v->cv != NULL && nchrs <= v->cv->chrspace &&
 5904 tgl@sss.pgh.pa.us         118         [ +  - ]:           1137 :         nranges <= v->cv->rangespace)
 7559 bruce@momjian.us          119                 :           1137 :         return clearcvec(v->cv);
                                120                 :                : 
                                121                 :                :     /* nope, make a new one */
                                122         [ +  - ]:              1 :     if (v->cv != NULL)
                                123                 :              1 :         freecvec(v->cv);
 5904 tgl@sss.pgh.pa.us         124                 :              1 :     v->cv = newcvec(nchrs, nranges);
 7559 bruce@momjian.us          125         [ -  + ]:              1 :     if (v->cv == NULL)
 7559 bruce@momjian.us          126         [ #  # ]:UBC           0 :         ERR(REG_ESPACE);
                                127                 :                : 
 7559 bruce@momjian.us          128                 :CBC           1 :     return v->cv;
                                129                 :                : }
                                130                 :                : 
                                131                 :                : /*
                                132                 :                :  * freecvec - free a cvec
                                133                 :                :  */
                                134                 :                : static void
 2489 tgl@sss.pgh.pa.us         135                 :           3611 : freecvec(struct cvec *cv)
                                136                 :                : {
 7559 bruce@momjian.us          137                 :           3611 :     FREE(cv);
 7739 tgl@sss.pgh.pa.us         138                 :           3611 : }
        

Generated by: LCOV version 2.1-beta2-3-g6141622