1			#define PERL_constant_NOTFOUND	1
     2			#define PERL_constant_NOTDEF	2
     3			#define PERL_constant_ISIV	3
     4			#define PERL_constant_ISNO	4
     5			#define PERL_constant_ISNV	5
     6			#define PERL_constant_ISPV	6
     7			#define PERL_constant_ISPVN	7
     8			#define PERL_constant_ISSV	8
     9			#define PERL_constant_ISUNDEF	9
    10			#define PERL_constant_ISUV	10
    11			#define PERL_constant_ISYES	11
    12			
    13			#ifndef NVTYPE
    14			typedef double NV; /* 5.6 and later define NVTYPE, and typedef NV to it.  */
    15			#endif
    16			#ifndef aTHX_
    17			#define aTHX_ /* 5.6 or later define this for threading support.  */
    18			#endif
    19			#ifndef pTHX_
    20			#define pTHX_ /* 5.6 or later define this for threading support.  */
    21			#endif
    22			
    23			static int
    24	      ######    constant_7 (pTHX_ const char *name, IV *iv_return) {
    25			  /* When generated this function returned values for the list of names given
    26			     here.  However, subsequent manual editing may have added or removed some.
    27			     LOG_ERR LOG_FTP LOG_LPR LOG_PID */
    28			  /* Offset 4 gives the best switch position.  */
    29	      ######      switch (name[4]) {
    30			  case 'E':
    31	      ######        if (memEQ(name, "LOG_ERR", 7)) {
    32			    /*                   ^        */
    33			#ifdef LOG_ERR
    34	      ######          *iv_return = LOG_ERR;
    35	      ######          return PERL_constant_ISIV;
    36			#else
    37			      return PERL_constant_NOTDEF;
    38			#endif
    39			    }
    40	      ######        break;
    41			  case 'F':
    42	      ######        if (memEQ(name, "LOG_FTP", 7)) {
    43			    /*                   ^        */
    44			#ifdef LOG_FTP
    45	      ######          *iv_return = LOG_FTP;
    46	      ######          return PERL_constant_ISIV;
    47			#else
    48			      return PERL_constant_NOTDEF;
    49			#endif
    50			    }
    51	      ######        break;
    52			  case 'L':
    53	      ######        if (memEQ(name, "LOG_LPR", 7)) {
    54			    /*                   ^        */
    55			#ifdef LOG_LPR
    56	      ######          *iv_return = LOG_LPR;
    57	      ######          return PERL_constant_ISIV;
    58			#else
    59			      return PERL_constant_NOTDEF;
    60			#endif
    61			    }
    62	      ######        break;
    63			  case 'P':
    64	      ######        if (memEQ(name, "LOG_PID", 7)) {
    65			    /*                   ^        */
    66			#ifdef LOG_PID
    67	      ######          *iv_return = LOG_PID;
    68	      ######          return PERL_constant_ISIV;
    69			#else
    70			      return PERL_constant_NOTDEF;
    71			#endif
    72			    }
    73	      ######        break;
    74			  }
    75	      ######      return PERL_constant_NOTFOUND;
    76			}
    77			
    78			static int
    79	           1    constant_8 (pTHX_ const char *name, IV *iv_return) {
    80			  /* When generated this function returned values for the list of names given
    81			     here.  However, subsequent manual editing may have added or removed some.
    82			     LOG_AUTH LOG_CONS LOG_CRIT LOG_CRON LOG_INFO LOG_KERN LOG_LFMT LOG_MAIL
    83			     LOG_NEWS LOG_USER LOG_UUCP */
    84			  /* Offset 6 gives the best switch position.  */
    85	           1      switch (name[6]) {
    86			  case 'C':
    87	      ######        if (memEQ(name, "LOG_UUCP", 8)) {
    88			    /*                     ^       */
    89			#ifdef LOG_UUCP
    90	      ######          *iv_return = LOG_UUCP;
    91	      ######          return PERL_constant_ISIV;
    92			#else
    93			      return PERL_constant_NOTDEF;
    94			#endif
    95			    }
    96	      ######        break;
    97			  case 'E':
    98	      ######        if (memEQ(name, "LOG_USER", 8)) {
    99			    /*                     ^       */
   100			#ifdef LOG_USER
   101	      ######          *iv_return = LOG_USER;
   102	      ######          return PERL_constant_ISIV;
   103			#else
   104			      return PERL_constant_NOTDEF;
   105			#endif
   106			    }
   107	           1        break;
   108			  case 'F':
   109	           1        if (memEQ(name, "LOG_INFO", 8)) {
   110			    /*                     ^       */
   111			#ifdef LOG_INFO
   112	           1          *iv_return = LOG_INFO;
   113	           1          return PERL_constant_ISIV;
   114			#else
   115			      return PERL_constant_NOTDEF;
   116			#endif
   117			    }
   118	      ######        break;
   119			  case 'I':
   120	      ######        if (memEQ(name, "LOG_CRIT", 8)) {
   121			    /*                     ^       */
   122			#ifdef LOG_CRIT
   123	      ######          *iv_return = LOG_CRIT;
   124	      ######          return PERL_constant_ISIV;
   125			#else
   126			      return PERL_constant_NOTDEF;
   127			#endif
   128			    }
   129	      ######        if (memEQ(name, "LOG_MAIL", 8)) {
   130			    /*                     ^       */
   131			#ifdef LOG_MAIL
   132	      ######          *iv_return = LOG_MAIL;
   133	      ######          return PERL_constant_ISIV;
   134			#else
   135			      return PERL_constant_NOTDEF;
   136			#endif
   137			    }
   138	      ######        break;
   139			  case 'M':
   140	      ######        if (memEQ(name, "LOG_LFMT", 8)) {
   141			    /*                     ^       */
   142			#ifdef LOG_LFMT
   143			      *iv_return = LOG_LFMT;
   144			      return PERL_constant_ISIV;
   145			#else
   146	      ######          return PERL_constant_NOTDEF;
   147			#endif
   148			    }
   149	      ######        break;
   150			  case 'N':
   151	      ######        if (memEQ(name, "LOG_CONS", 8)) {
   152			    /*                     ^       */
   153			#ifdef LOG_CONS
   154	      ######          *iv_return = LOG_CONS;
   155	      ######          return PERL_constant_ISIV;
   156			#else
   157			      return PERL_constant_NOTDEF;
   158			#endif
   159			    }
   160	      ######        break;
   161			  case 'O':
   162	      ######        if (memEQ(name, "LOG_CRON", 8)) {
   163			    /*                     ^       */
   164			#ifdef LOG_CRON
   165	      ######          *iv_return = LOG_CRON;
   166	      ######          return PERL_constant_ISIV;
   167			#else
   168			      return PERL_constant_NOTDEF;
   169			#endif
   170			    }
   171	      ######        break;
   172			  case 'R':
   173	      ######        if (memEQ(name, "LOG_KERN", 8)) {
   174			    /*                     ^       */
   175			#ifdef LOG_KERN
   176	      ######          *iv_return = LOG_KERN;
   177	      ######          return PERL_constant_ISIV;
   178			#else
   179			      return PERL_constant_NOTDEF;
   180			#endif
   181			    }
   182	      ######        break;
   183			  case 'T':
   184	      ######        if (memEQ(name, "LOG_AUTH", 8)) {
   185			    /*                     ^       */
   186			#ifdef LOG_AUTH
   187	      ######          *iv_return = LOG_AUTH;
   188	      ######          return PERL_constant_ISIV;
   189			#else
   190			      return PERL_constant_NOTDEF;
   191			#endif
   192			    }
   193	      ######        break;
   194			  case 'W':
   195	      ######        if (memEQ(name, "LOG_NEWS", 8)) {
   196			    /*                     ^       */
   197			#ifdef LOG_NEWS
   198	      ######          *iv_return = LOG_NEWS;
   199	      ######          return PERL_constant_ISIV;
   200			#else
   201			      return PERL_constant_NOTDEF;
   202			#endif
   203			    }
   204	      ######        break;
   205			  }
   206	      ######      return PERL_constant_NOTFOUND;
   207			}
   208			
   209			static int
   210	           2    constant_9 (pTHX_ const char *name, IV *iv_return, const char **pv_return) {
   211			  /* When generated this function returned values for the list of names given
   212			     here.  However, subsequent manual editing may have added or removed some.
   213			     LOG_ALERT LOG_DEBUG LOG_EMERG _PATH_LOG */
   214			  /* Offset 4 gives the best switch position.  */
   215	           2      switch (name[4]) {
   216			  case 'A':
   217	      ######        if (memEQ(name, "LOG_ALERT", 9)) {
   218			    /*                   ^          */
   219			#ifdef LOG_ALERT
   220	      ######          *iv_return = LOG_ALERT;
   221	      ######          return PERL_constant_ISIV;
   222			#else
   223			      return PERL_constant_NOTDEF;
   224			#endif
   225			    }
   226	           1        break;
   227			  case 'D':
   228	           1        if (memEQ(name, "LOG_DEBUG", 9)) {
   229			    /*                   ^          */
   230			#ifdef LOG_DEBUG
   231	           1          *iv_return = LOG_DEBUG;
   232	           1          return PERL_constant_ISIV;
   233			#else
   234			      return PERL_constant_NOTDEF;
   235			#endif
   236			    }
   237	      ######        break;
   238			  case 'E':
   239	      ######        if (memEQ(name, "LOG_EMERG", 9)) {
   240			    /*                   ^          */
   241			#ifdef LOG_EMERG
   242	      ######          *iv_return = LOG_EMERG;
   243	      ######          return PERL_constant_ISIV;
   244			#else
   245			      return PERL_constant_NOTDEF;
   246			#endif
   247			    }
   248	           1        break;
   249			  case 'H':
   250	           1        if (memEQ(name, "_PATH_LOG", 9)) {
   251			    /*                   ^          */
   252			#ifdef _PATH_LOG
   253	           1          *pv_return = _PATH_LOG;
   254	           1          return PERL_constant_ISPV;
   255			#else
   256			      *pv_return = "/dev/log";
   257			      return PERL_constant_ISPV;
   258			#endif
   259			    }
   260	      ######        break;
   261			  }
   262	      ######      return PERL_constant_NOTFOUND;
   263			}
   264			
   265			static int
   266	           1    constant_10 (pTHX_ const char *name, IV *iv_return) {
   267			  /* When generated this function returned values for the list of names given
   268			     here.  However, subsequent manual editing may have added or removed some.
   269			     LOG_DAEMON LOG_LOCAL0 LOG_LOCAL1 LOG_LOCAL2 LOG_LOCAL3 LOG_LOCAL4
   270			     LOG_LOCAL5 LOG_LOCAL6 LOG_LOCAL7 LOG_NDELAY LOG_NOTICE LOG_NOWAIT
   271			     LOG_ODELAY LOG_PERROR LOG_SYSLOG */
   272			  /* Offset 9 gives the best switch position.  */
   273	           1      switch (name[9]) {
   274			  case '0':
   275	           1        if (memEQ(name, "LOG_LOCAL", 9)) {
   276			    /*                        0     */
   277			#ifdef LOG_LOCAL0
   278	           1          *iv_return = LOG_LOCAL0;
   279	           1          return PERL_constant_ISIV;
   280			#else
   281			      return PERL_constant_NOTDEF;
   282			#endif
   283			    }
   284	      ######        break;
   285			  case '1':
   286	      ######        if (memEQ(name, "LOG_LOCAL", 9)) {
   287			    /*                        1     */
   288			#ifdef LOG_LOCAL1
   289	      ######          *iv_return = LOG_LOCAL1;
   290	      ######          return PERL_constant_ISIV;
   291			#else
   292			      return PERL_constant_NOTDEF;
   293			#endif
   294			    }
   295	      ######        break;
   296			  case '2':
   297	      ######        if (memEQ(name, "LOG_LOCAL", 9)) {
   298			    /*                        2     */
   299			#ifdef LOG_LOCAL2
   300	      ######          *iv_return = LOG_LOCAL2;
   301	      ######          return PERL_constant_ISIV;
   302			#else
   303			      return PERL_constant_NOTDEF;
   304			#endif
   305			    }
   306	      ######        break;
   307			  case '3':
   308	      ######        if (memEQ(name, "LOG_LOCAL", 9)) {
   309			    /*                        3     */
   310			#ifdef LOG_LOCAL3
   311	      ######          *iv_return = LOG_LOCAL3;
   312	      ######          return PERL_constant_ISIV;
   313			#else
   314			      return PERL_constant_NOTDEF;
   315			#endif
   316			    }
   317	      ######        break;
   318			  case '4':
   319	      ######        if (memEQ(name, "LOG_LOCAL", 9)) {
   320			    /*                        4     */
   321			#ifdef LOG_LOCAL4
   322	      ######          *iv_return = LOG_LOCAL4;
   323	      ######          return PERL_constant_ISIV;
   324			#else
   325			      return PERL_constant_NOTDEF;
   326			#endif
   327			    }
   328	      ######        break;
   329			  case '5':
   330	      ######        if (memEQ(name, "LOG_LOCAL", 9)) {
   331			    /*                        5     */
   332			#ifdef LOG_LOCAL5
   333	      ######          *iv_return = LOG_LOCAL5;
   334	      ######          return PERL_constant_ISIV;
   335			#else
   336			      return PERL_constant_NOTDEF;
   337			#endif
   338			    }
   339	      ######        break;
   340			  case '6':
   341	      ######        if (memEQ(name, "LOG_LOCAL", 9)) {
   342			    /*                        6     */
   343			#ifdef LOG_LOCAL6
   344	      ######          *iv_return = LOG_LOCAL6;
   345	      ######          return PERL_constant_ISIV;
   346			#else
   347			      return PERL_constant_NOTDEF;
   348			#endif
   349			    }
   350	      ######        break;
   351			  case '7':
   352	      ######        if (memEQ(name, "LOG_LOCAL", 9)) {
   353			    /*                        7     */
   354			#ifdef LOG_LOCAL7
   355	      ######          *iv_return = LOG_LOCAL7;
   356	      ######          return PERL_constant_ISIV;
   357			#else
   358			      return PERL_constant_NOTDEF;
   359			#endif
   360			    }
   361	      ######        break;
   362			  case 'E':
   363	      ######        if (memEQ(name, "LOG_NOTIC", 9)) {
   364			    /*                        E     */
   365			#ifdef LOG_NOTICE
   366	      ######          *iv_return = LOG_NOTICE;
   367	      ######          return PERL_constant_ISIV;
   368			#else
   369			      return PERL_constant_NOTDEF;
   370			#endif
   371			    }
   372	      ######        break;
   373			  case 'G':
   374	      ######        if (memEQ(name, "LOG_SYSLO", 9)) {
   375			    /*                        G     */
   376			#ifdef LOG_SYSLOG
   377	      ######          *iv_return = LOG_SYSLOG;
   378	      ######          return PERL_constant_ISIV;
   379			#else
   380			      return PERL_constant_NOTDEF;
   381			#endif
   382			    }
   383	      ######        break;
   384			  case 'N':
   385	      ######        if (memEQ(name, "LOG_DAEMO", 9)) {
   386			    /*                        N     */
   387			#ifdef LOG_DAEMON
   388	      ######          *iv_return = LOG_DAEMON;
   389	      ######          return PERL_constant_ISIV;
   390			#else
   391			      return PERL_constant_NOTDEF;
   392			#endif
   393			    }
   394	      ######        break;
   395			  case 'R':
   396	      ######        if (memEQ(name, "LOG_PERRO", 9)) {
   397			    /*                        R     */
   398			#ifdef LOG_PERROR
   399	      ######          *iv_return = LOG_PERROR;
   400	      ######          return PERL_constant_ISIV;
   401			#else
   402			      return PERL_constant_NOTDEF;
   403			#endif
   404			    }
   405	      ######        break;
   406			  case 'T':
   407	      ######        if (memEQ(name, "LOG_NOWAI", 9)) {
   408			    /*                        T     */
   409			#ifdef LOG_NOWAIT
   410	      ######          *iv_return = LOG_NOWAIT;
   411	      ######          return PERL_constant_ISIV;
   412			#else
   413			      return PERL_constant_NOTDEF;
   414			#endif
   415			    }
   416	      ######        break;
   417			  case 'Y':
   418	      ######        if (memEQ(name, "LOG_NDELA", 9)) {
   419			    /*                        Y     */
   420			#ifdef LOG_NDELAY
   421	      ######          *iv_return = LOG_NDELAY;
   422	      ######          return PERL_constant_ISIV;
   423			#else
   424			      return PERL_constant_NOTDEF;
   425			#endif
   426			    }
   427	      ######        if (memEQ(name, "LOG_ODELA", 9)) {
   428			    /*                        Y     */
   429			#ifdef LOG_ODELAY
   430	      ######          *iv_return = LOG_ODELAY;
   431	      ######          return PERL_constant_ISIV;
   432			#else
   433			      return PERL_constant_NOTDEF;
   434			#endif
   435			    }
   436	      ######        break;
   437			  }
   438	      ######      return PERL_constant_NOTFOUND;
   439			}
   440			
   441			static int
   442	           1    constant_11 (pTHX_ const char *name, IV *iv_return) {
   443			  /* When generated this function returned values for the list of names given
   444			     here.  However, subsequent manual editing may have added or removed some.
   445			     LOG_FACMASK LOG_PRIMASK LOG_WARNING */
   446			  /* Offset 6 gives the best switch position.  */
   447	           1      switch (name[6]) {
   448			  case 'C':
   449	      ######        if (memEQ(name, "LOG_FACMASK", 11)) {
   450			    /*                     ^           */
   451			#ifdef LOG_FACMASK
   452	      ######          *iv_return = LOG_FACMASK;
   453	      ######          return PERL_constant_ISIV;
   454			#else
   455			      return PERL_constant_NOTDEF;
   456			#endif
   457			    }
   458	           1        break;
   459			  case 'I':
   460	           1        if (memEQ(name, "LOG_PRIMASK", 11)) {
   461			    /*                     ^           */
   462			#ifdef LOG_PRIMASK
   463	           1          *iv_return = LOG_PRIMASK;
   464	           1          return PERL_constant_ISIV;
   465			#else
   466			      return PERL_constant_NOTDEF;
   467			#endif
   468			    }
   469	      ######        break;
   470			  case 'R':
   471	      ######        if (memEQ(name, "LOG_WARNING", 11)) {
   472			    /*                     ^           */
   473			#ifdef LOG_WARNING
   474	      ######          *iv_return = LOG_WARNING;
   475	      ######          return PERL_constant_ISIV;
   476			#else
   477			      return PERL_constant_NOTDEF;
   478			#endif
   479			    }
   480	      ######        break;
   481			  }
   482	      ######      return PERL_constant_NOTFOUND;
   483			}
   484			
   485			static int
   486	           5    constant (pTHX_ const char *name, STRLEN len, IV *iv_return, const char **pv_return) {
   487			  /* Initially switch on the length of the name.  */
   488			  /* When generated this function returned values for the list of names given
   489			     in this section of perl code.  Rather than manually editing these functions
   490			     to add or remove constants, which would result in this comment and section
   491			     of code becoming inaccurate, we recommend that you edit this section of
   492			     code, and use it to regenerate a new set of constant functions which you
   493			     then use to replace the originals.
   494			
   495			     Regenerate these constant functions by feeding this entire source file to
   496			     perl -x
   497			
   498			#!/home/nick/Perl/25060-g-gcov/miniperl -w
   499			use ExtUtils::Constant qw (constant_types C_constant XS_constant);
   500			
   501			my $types = {map {($_, 1)} qw(IV PV)};
   502			my @names = (qw(LOG_ALERT LOG_AUTH LOG_AUTHPRIV LOG_CONS LOG_CRIT LOG_CRON
   503				       LOG_DAEMON LOG_DEBUG LOG_EMERG LOG_ERR LOG_FACMASK LOG_FTP
   504				       LOG_INFO LOG_KERN LOG_LFMT LOG_LOCAL0 LOG_LOCAL1 LOG_LOCAL2
   505				       LOG_LOCAL3 LOG_LOCAL4 LOG_LOCAL5 LOG_LOCAL6 LOG_LOCAL7 LOG_LPR
   506				       LOG_MAIL LOG_NDELAY LOG_NEWS LOG_NFACILITIES LOG_NOTICE
   507				       LOG_NOWAIT LOG_ODELAY LOG_PERROR LOG_PID LOG_PRIMASK LOG_SYSLOG
   508				       LOG_USER LOG_UUCP LOG_WARNING),
   509			            {name=>"_PATH_LOG", type=>"PV", default=>["PV", "\"/dev/log\""]});
   510			
   511			print constant_types(); # macro defs
   512			foreach (C_constant ("Sys::Syslog", 'constant', 'IV', $types, undef, 3, @names) ) {
   513			    print $_, "\n"; # C constant subs
   514			}
   515			print "#### XS Section:\n";
   516			print XS_constant ("Sys::Syslog", $types);
   517			__END__
   518			   */
   519			
   520	           5      switch (len) {
   521			  case 7:
   522	      ######        return constant_7 (aTHX_ name, iv_return);
   523	           1        break;
   524			  case 8:
   525	           1        return constant_8 (aTHX_ name, iv_return);
   526	           2        break;
   527			  case 9:
   528	           2        return constant_9 (aTHX_ name, iv_return, pv_return);
   529	           1        break;
   530			  case 10:
   531	           1        return constant_10 (aTHX_ name, iv_return);
   532	           1        break;
   533			  case 11:
   534	           1        return constant_11 (aTHX_ name, iv_return);
   535	      ######        break;
   536			  case 12:
   537	      ######        if (memEQ(name, "LOG_AUTHPRIV", 12)) {
   538			#ifdef LOG_AUTHPRIV
   539	      ######          *iv_return = LOG_AUTHPRIV;
   540	      ######          return PERL_constant_ISIV;
   541			#else
   542			      return PERL_constant_NOTDEF;
   543			#endif
   544			    }
   545	      ######        break;
   546			  case 15:
   547	      ######        if (memEQ(name, "LOG_NFACILITIES", 15)) {
   548			#ifdef LOG_NFACILITIES
   549	      ######          *iv_return = LOG_NFACILITIES;
   550	      ######          return PERL_constant_ISIV;
   551			#else
   552			      return PERL_constant_NOTDEF;
   553			#endif
   554			    }
   555	      ######        break;
   556			  }
   557	      ######      return PERL_constant_NOTFOUND;
   558			}
   559