LCOV - differential code coverage report
Current view: top level - src/fe_utils - option_utils.c (source / functions) Coverage Total Hit UNC UBC GNC CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 90.3 % 31 28 3 5 23
Current Date: 2024-04-14 14:21:10 Functions: 100.0 % 3 3 1 2
Baseline: 16@8cea358b128 Branches: 82.1 % 28 23 2 3 2 21
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (180,240] days: 62.5 % 8 5 3 5
(240..) days: 100.0 % 23 23 23
Function coverage date bins:
(180,240] days: 100.0 % 1 1 1
(240..) days: 100.0 % 2 2 2
Branch coverage date bins:
(180,240] days: 50.0 % 4 2 2 2
(240..) days: 87.5 % 24 21 3 21

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : /*-------------------------------------------------------------------------
                                  2                 :                :  *
                                  3                 :                :  * Command line option processing facilities for frontend code
                                  4                 :                :  *
                                  5                 :                :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
                                  6                 :                :  * Portions Copyright (c) 1994, Regents of the University of California
                                  7                 :                :  *
                                  8                 :                :  * src/fe_utils/option_utils.c
                                  9                 :                :  *
                                 10                 :                :  *-------------------------------------------------------------------------
                                 11                 :                :  */
                                 12                 :                : 
                                 13                 :                : #include "postgres_fe.h"
                                 14                 :                : 
                                 15                 :                : #include "common/logging.h"
                                 16                 :                : #include "common/string.h"
                                 17                 :                : #include "fe_utils/option_utils.h"
                                 18                 :                : 
                                 19                 :                : /*
                                 20                 :                :  * Provide strictly harmonized handling of --help and --version
                                 21                 :                :  * options.
                                 22                 :                :  */
                                 23                 :                : void
 1164 rhaas@postgresql.org       24                 :CBC         302 : handle_help_version_opts(int argc, char *argv[],
                                 25                 :                :                          const char *fixed_progname, help_handler hlp)
                                 26                 :                : {
                                 27         [ +  + ]:            302 :     if (argc > 1)
                                 28                 :                :     {
                                 29   [ +  +  -  + ]:            298 :         if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
                                 30                 :                :         {
                                 31                 :             11 :             hlp(get_progname(argv[0]));
                                 32                 :             11 :             exit(0);
                                 33                 :                :         }
                                 34   [ +  +  +  + ]:            287 :         if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
                                 35                 :                :         {
                                 36                 :             20 :             printf("%s (PostgreSQL) " PG_VERSION "\n", fixed_progname);
                                 37                 :             20 :             exit(0);
                                 38                 :                :         }
                                 39                 :                :     }
                                 40                 :            271 : }
                                 41                 :                : 
                                 42                 :                : /*
                                 43                 :                :  * option_parse_int
                                 44                 :                :  *
                                 45                 :                :  * Parse integer value for an option.  If the parsing is successful, returns
                                 46                 :                :  * true and stores the result in *result if that's given; if parsing fails,
                                 47                 :                :  * returns false.
                                 48                 :                :  */
                                 49                 :                : bool
  995 michael@paquier.xyz        50                 :            209 : option_parse_int(const char *optarg, const char *optname,
                                 51                 :                :                  int min_range, int max_range,
                                 52                 :                :                  int *result)
                                 53                 :                : {
                                 54                 :                :     char       *endptr;
                                 55                 :                :     int         val;
                                 56                 :                : 
                                 57                 :            209 :     errno = 0;
                                 58                 :            209 :     val = strtoint(optarg, &endptr, 10);
                                 59                 :                : 
                                 60                 :                :     /*
                                 61                 :                :      * Skip any trailing whitespace; if anything but whitespace remains before
                                 62                 :                :      * the terminating character, fail.
                                 63                 :                :      */
  992                            64   [ +  +  +  + ]:            210 :     while (*endptr != '\0' && isspace((unsigned char) *endptr))
                                 65                 :              1 :         endptr++;
                                 66                 :                : 
                                 67         [ +  + ]:            209 :     if (*endptr != '\0')
                                 68                 :                :     {
  995                            69                 :              6 :         pg_log_error("invalid value \"%s\" for option %s",
                                 70                 :                :                      optarg, optname);
                                 71                 :              6 :         return false;
                                 72                 :                :     }
                                 73                 :                : 
                                 74   [ +  -  +  +  :            203 :     if (errno == ERANGE || val < min_range || val > max_range)
                                              -  + ]
                                 75                 :                :     {
                                 76                 :             11 :         pg_log_error("%s must be in range %d..%d",
                                 77                 :                :                      optname, min_range, max_range);
                                 78                 :             11 :         return false;
                                 79                 :                :     }
                                 80                 :                : 
                                 81         [ +  + ]:            192 :     if (result)
                                 82                 :            186 :         *result = val;
                                 83                 :            192 :     return true;
                                 84                 :                : }
                                 85                 :                : 
                                 86                 :                : /*
                                 87                 :                :  * Provide strictly harmonized handling of the --sync-method option.
                                 88                 :                :  */
                                 89                 :                : bool
  221 nathan@postgresql.or       90                 :GNC           1 : parse_sync_method(const char *optarg, DataDirSyncMethod *sync_method)
                                 91                 :                : {
                                 92         [ -  + ]:              1 :     if (strcmp(optarg, "fsync") == 0)
  221 nathan@postgresql.or       93                 :UNC           0 :         *sync_method = DATA_DIR_SYNC_METHOD_FSYNC;
  221 nathan@postgresql.or       94         [ +  - ]:GNC           1 :     else if (strcmp(optarg, "syncfs") == 0)
                                 95                 :                :     {
                                 96                 :                : #ifdef HAVE_SYNCFS
                                 97                 :              1 :         *sync_method = DATA_DIR_SYNC_METHOD_SYNCFS;
                                 98                 :                : #else
                                 99                 :                :         pg_log_error("this build does not support sync method \"%s\"",
                                100                 :                :                      "syncfs");
                                101                 :                :         return false;
                                102                 :                : #endif
                                103                 :                :     }
                                104                 :                :     else
                                105                 :                :     {
  221 nathan@postgresql.or      106                 :UNC           0 :         pg_log_error("unrecognized sync method: %s", optarg);
                                107                 :              0 :         return false;
                                108                 :                :     }
                                109                 :                : 
  221 nathan@postgresql.or      110                 :GNC           1 :     return true;
                                111                 :                : }
        

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