LCOV - code coverage report
Current view: top level - gl - getopt.h (source / functions) Hit Total Coverage
Test: GNU Libidn Lines: 3 3 100.0 %
Date: 2013-07-10 Functions: 3 3 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* DO NOT EDIT! GENERATED AUTOMATICALLY! */
       2                 :            : /* Declarations for getopt.
       3                 :            :    Copyright (C) 1989-1994, 1996-1999, 2001, 2003-2007, 2009-2013 Free Software
       4                 :            :    Foundation, Inc.
       5                 :            :    This file is part of the GNU C Library.
       6                 :            : 
       7                 :            :    This program is free software: you can redistribute it and/or modify
       8                 :            :    it under the terms of the GNU General Public License as published by
       9                 :            :    the Free Software Foundation; either version 3 of the License, or
      10                 :            :    (at your option) any later version.
      11                 :            : 
      12                 :            :    This program is distributed in the hope that it will be useful,
      13                 :            :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            :    GNU General Public License for more details.
      16                 :            : 
      17                 :            :    You should have received a copy of the GNU General Public License
      18                 :            :    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #ifndef _GL_GETOPT_H
      21                 :            : 
      22                 :            : #if __GNUC__ >= 3
      23                 :            : #pragma GCC system_header
      24                 :            : #endif
      25                 :            : 
      26                 :            : 
      27                 :            : /* The include_next requires a split double-inclusion guard.  We must
      28                 :            :    also inform the replacement unistd.h to not recursively use
      29                 :            :    <getopt.h>; our definitions will be present soon enough.  */
      30                 :            : #if 1
      31                 :            : # define _GL_SYSTEM_GETOPT
      32                 :            : # include_next <getopt.h>
      33                 :            : # undef _GL_SYSTEM_GETOPT
      34                 :            : #endif
      35                 :            : 
      36                 :            : #ifndef _GL_GETOPT_H
      37                 :            : 
      38                 :            : #ifndef __need_getopt
      39                 :            : # define _GL_GETOPT_H 1
      40                 :            : #endif
      41                 :            : 
      42                 :            : /* Standalone applications should #define __GETOPT_PREFIX to an
      43                 :            :    identifier that prefixes the external functions and variables
      44                 :            :    defined in this header.  When this happens, include the
      45                 :            :    headers that might declare getopt so that they will not cause
      46                 :            :    confusion if included after this file (if the system had <getopt.h>,
      47                 :            :    we have already included it).  Then systematically rename
      48                 :            :    identifiers so that they do not collide with the system functions
      49                 :            :    and variables.  Renaming avoids problems with some compilers and
      50                 :            :    linkers.  */
      51                 :            : #if defined __GETOPT_PREFIX && !defined __need_getopt
      52                 :            : # if !1
      53                 :            : #  define __need_system_stdlib_h
      54                 :            : #  include <stdlib.h>
      55                 :            : #  undef __need_system_stdlib_h
      56                 :            : #  include <stdio.h>
      57                 :            : #  include <unistd.h>
      58                 :            : # endif
      59                 :            : # undef __need_getopt
      60                 :            : # undef getopt
      61                 :            : # undef getopt_long
      62                 :            : # undef getopt_long_only
      63                 :            : # undef optarg
      64                 :            : # undef opterr
      65                 :            : # undef optind
      66                 :            : # undef optopt
      67                 :            : # undef option
      68                 :            : # define __GETOPT_CONCAT(x, y) x ## y
      69                 :            : # define __GETOPT_XCONCAT(x, y) __GETOPT_CONCAT (x, y)
      70                 :            : # define __GETOPT_ID(y) __GETOPT_XCONCAT (__GETOPT_PREFIX, y)
      71                 :            : # define getopt __GETOPT_ID (getopt)
      72                 :            : # define getopt_long __GETOPT_ID (getopt_long)
      73                 :            : # define getopt_long_only __GETOPT_ID (getopt_long_only)
      74                 :            : # define optarg __GETOPT_ID (optarg)
      75                 :            : # define opterr __GETOPT_ID (opterr)
      76                 :            : # define optind __GETOPT_ID (optind)
      77                 :            : # define optopt __GETOPT_ID (optopt)
      78                 :            : # define option __GETOPT_ID (option)
      79                 :            : # define _getopt_internal __GETOPT_ID (getopt_internal)
      80                 :            : #endif
      81                 :            : 
      82                 :            : /* Standalone applications get correct prototypes for getopt_long and
      83                 :            :    getopt_long_only; they declare "char **argv".  libc uses prototypes
      84                 :            :    with "char *const *argv" that are incorrect because getopt_long and
      85                 :            :    getopt_long_only can permute argv; this is required for backward
      86                 :            :    compatibility (e.g., for LSB 2.0.1).
      87                 :            : 
      88                 :            :    This used to be '#if defined __GETOPT_PREFIX && !defined __need_getopt',
      89                 :            :    but it caused redefinition warnings if both unistd.h and getopt.h were
      90                 :            :    included, since unistd.h includes getopt.h having previously defined
      91                 :            :    __need_getopt.
      92                 :            : 
      93                 :            :    The only place where __getopt_argv_const is used is in definitions
      94                 :            :    of getopt_long and getopt_long_only below, but these are visible
      95                 :            :    only if __need_getopt is not defined, so it is quite safe to rewrite
      96                 :            :    the conditional as follows:
      97                 :            : */
      98                 :            : #if !defined __need_getopt
      99                 :            : # if defined __GETOPT_PREFIX
     100                 :            : #  define __getopt_argv_const /* empty */
     101                 :            : # else
     102                 :            : #  define __getopt_argv_const const
     103                 :            : # endif
     104                 :            : #endif
     105                 :            : 
     106                 :            : /* If __GNU_LIBRARY__ is not already defined, either we are being used
     107                 :            :    standalone, or this is the first header included in the source file.
     108                 :            :    If we are being used with glibc, we need to include <features.h>, but
     109                 :            :    that does not exist if we are standalone.  So: if __GNU_LIBRARY__ is
     110                 :            :    not defined, include <ctype.h>, which will pull in <features.h> for us
     111                 :            :    if it's from glibc.  (Why ctype.h?  It's guaranteed to exist and it
     112                 :            :    doesn't flood the namespace with stuff the way some other headers do.)  */
     113                 :            : #if !defined __GNU_LIBRARY__
     114                 :            : # include <ctype.h>
     115                 :            : #endif
     116                 :            : 
     117                 :            : #ifndef __THROW
     118                 :            : # ifndef __GNUC_PREREQ
     119                 :            : #  define __GNUC_PREREQ(maj, min) (0)
     120                 :            : # endif
     121                 :            : # if defined __cplusplus && __GNUC_PREREQ (2,8)
     122                 :            : #  define __THROW       throw ()
     123                 :            : # else
     124                 :            : #  define __THROW
     125                 :            : # endif
     126                 :            : #endif
     127                 :            : 
     128                 :            : /* The definition of _GL_ARG_NONNULL is copied here.  */
     129                 :            : /* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools
     130                 :            :    that the values passed as arguments n, ..., m must be non-NULL pointers.
     131                 :            :    n = 1 stands for the first argument, n = 2 for the second argument etc.  */
     132                 :            : #ifndef _GL_ARG_NONNULL
     133                 :            : # if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3
     134                 :            : #  define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))
     135                 :            : # else
     136                 :            : #  define _GL_ARG_NONNULL(params)
     137                 :            : # endif
     138                 :            : #endif
     139                 :            : 
     140                 :            : #ifdef __cplusplus
     141                 :            : extern "C" {
     142                 :            : #endif
     143                 :            : 
     144                 :            : /* For communication from 'getopt' to the caller.
     145                 :            :    When 'getopt' finds an option that takes an argument,
     146                 :            :    the argument value is returned here.
     147                 :            :    Also, when 'ordering' is RETURN_IN_ORDER,
     148                 :            :    each non-option ARGV-element is returned here.  */
     149                 :            : 
     150                 :            : extern char *optarg;
     151                 :            : 
     152                 :            : /* Index in ARGV of the next element to be scanned.
     153                 :            :    This is used for communication to and from the caller
     154                 :            :    and for communication between successive calls to 'getopt'.
     155                 :            : 
     156                 :            :    On entry to 'getopt', zero means this is the first call; initialize.
     157                 :            : 
     158                 :            :    When 'getopt' returns -1, this is the index of the first of the
     159                 :            :    non-option elements that the caller should itself scan.
     160                 :            : 
     161                 :            :    Otherwise, 'optind' communicates from one call to the next
     162                 :            :    how much of ARGV has been scanned so far.  */
     163                 :            : 
     164                 :            : extern int optind;
     165                 :            : 
     166                 :            : /* Callers store zero here to inhibit the error message 'getopt' prints
     167                 :            :    for unrecognized options.  */
     168                 :            : 
     169                 :            : extern int opterr;
     170                 :            : 
     171                 :            : /* Set to an option character which was unrecognized.  */
     172                 :            : 
     173                 :            : extern int optopt;
     174                 :            : 
     175                 :            : #ifndef __need_getopt
     176                 :            : /* Describe the long-named options requested by the application.
     177                 :            :    The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
     178                 :            :    of 'struct option' terminated by an element containing a name which is
     179                 :            :    zero.
     180                 :            : 
     181                 :            :    The field 'has_arg' is:
     182                 :            :    no_argument          (or 0) if the option does not take an argument,
     183                 :            :    required_argument    (or 1) if the option requires an argument,
     184                 :            :    optional_argument    (or 2) if the option takes an optional argument.
     185                 :            : 
     186                 :            :    If the field 'flag' is not NULL, it points to a variable that is set
     187                 :            :    to the value given in the field 'val' when the option is found, but
     188                 :            :    left unchanged if the option is not found.
     189                 :            : 
     190                 :            :    To have a long-named option do something other than set an 'int' to
     191                 :            :    a compiled-in constant, such as set a value from 'optarg', set the
     192                 :            :    option's 'flag' field to zero and its 'val' field to a nonzero
     193                 :            :    value (the equivalent single-letter option character, if there is
     194                 :            :    one).  For long options that have a zero 'flag' field, 'getopt'
     195                 :            :    returns the contents of the 'val' field.  */
     196                 :            : 
     197                 :            : # if !GNULIB_defined_struct_option
     198                 :            : struct option
     199                 :            : {
     200                 :            :   const char *name;
     201                 :            :   /* has_arg can't be an enum because some compilers complain about
     202                 :            :      type mismatches in all the code that assumes it is an int.  */
     203                 :            :   int has_arg;
     204                 :            :   int *flag;
     205                 :            :   int val;
     206                 :            : };
     207                 :            : #  define GNULIB_defined_struct_option 1
     208                 :            : # endif
     209                 :            : 
     210                 :            : /* Names for the values of the 'has_arg' field of 'struct option'.  */
     211                 :            : 
     212                 :            : # define no_argument            0
     213                 :            : # define required_argument      1
     214                 :            : # define optional_argument      2
     215                 :            : #endif  /* need getopt */
     216                 :            : 
     217                 :            : 
     218                 :            : /* Get definitions and prototypes for functions to process the
     219                 :            :    arguments in ARGV (ARGC of them, minus the program name) for
     220                 :            :    options given in OPTS.
     221                 :            : 
     222                 :            :    Return the option character from OPTS just read.  Return -1 when
     223                 :            :    there are no more options.  For unrecognized options, or options
     224                 :            :    missing arguments, 'optopt' is set to the option letter, and '?' is
     225                 :            :    returned.
     226                 :            : 
     227                 :            :    The OPTS string is a list of characters which are recognized option
     228                 :            :    letters, optionally followed by colons, specifying that that letter
     229                 :            :    takes an argument, to be placed in 'optarg'.
     230                 :            : 
     231                 :            :    If a letter in OPTS is followed by two colons, its argument is
     232                 :            :    optional.  This behavior is specific to the GNU 'getopt'.
     233                 :            : 
     234                 :            :    The argument '--' causes premature termination of argument
     235                 :            :    scanning, explicitly telling 'getopt' that there are no more
     236                 :            :    options.
     237                 :            : 
     238                 :            :    If OPTS begins with '-', then non-option arguments are treated as
     239                 :            :    arguments to the option '\1'.  This behavior is specific to the GNU
     240                 :            :    'getopt'.  If OPTS begins with '+', or POSIXLY_CORRECT is set in
     241                 :            :    the environment, then do not permute arguments.  */
     242                 :            : 
     243                 :        348 : extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
     244                 :            :        __THROW _GL_ARG_NONNULL ((2, 3));
     245                 :            : 
     246                 :            : #ifndef __need_getopt
     247                 :        281 : extern int getopt_long (int ___argc, char *__getopt_argv_const *___argv,
     248                 :            :                         const char *__shortopts,
     249                 :            :                         const struct option *__longopts, int *__longind)
     250                 :            :        __THROW _GL_ARG_NONNULL ((2, 3));
     251                 :         12 : extern int getopt_long_only (int ___argc, char *__getopt_argv_const *___argv,
     252                 :            :                              const char *__shortopts,
     253                 :            :                              const struct option *__longopts, int *__longind)
     254                 :            :        __THROW _GL_ARG_NONNULL ((2, 3));
     255                 :            : 
     256                 :            : #endif
     257                 :            : 
     258                 :            : #ifdef __cplusplus
     259                 :            : }
     260                 :            : #endif
     261                 :            : 
     262                 :            : /* Make sure we later can get all the definitions and declarations.  */
     263                 :            : #undef __need_getopt
     264                 :            : 
     265                 :            : #endif /* _GL_GETOPT_H */
     266                 :            : #endif /* _GL_GETOPT_H */

Generated by: LCOV version 1.9