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_5 (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			     FEXCL FSYNC O_RAW */
    28			  /* Offset 2 gives the best switch position.  */
    29	      ######      switch (name[2]) {
    30			  case 'R':
    31	      ######        if (memEQ(name, "O_RAW", 5)) {
    32			    /*                 ^        */
    33			#ifdef O_RAW
    34			      *iv_return = O_RAW;
    35			      return PERL_constant_ISIV;
    36			#else
    37	      ######          return PERL_constant_NOTDEF;
    38			#endif
    39			    }
    40	      ######        break;
    41			  case 'X':
    42	      ######        if (memEQ(name, "FEXCL", 5)) {
    43			    /*                 ^        */
    44			#ifdef FEXCL
    45			      *iv_return = FEXCL;
    46			      return PERL_constant_ISIV;
    47			#else
    48	      ######          return PERL_constant_NOTDEF;
    49			#endif
    50			    }
    51	      ######        break;
    52			  case 'Y':
    53	      ######        if (memEQ(name, "FSYNC", 5)) {
    54			    /*                 ^        */
    55			#ifdef FSYNC
    56			      *iv_return = FSYNC;
    57			      return PERL_constant_ISIV;
    58			#else
    59	      ######          return PERL_constant_NOTDEF;
    60			#endif
    61			    }
    62	      ######        break;
    63			  }
    64	      ######      return PERL_constant_NOTFOUND;
    65			}
    66			
    67			static int
    68	          59    constant_6 (pTHX_ const char *name, IV *iv_return) {
    69			  /* When generated this function returned values for the list of names given
    70			     here.  However, subsequent manual editing may have added or removed some.
    71			     FASYNC FCREAT FDEFER FDSYNC FRSYNC FTRUNC O_EXCL O_RDWR O_RSRC O_SYNC
    72			     O_TEXT */
    73			  /* Offset 3 gives the best switch position.  */
    74	          59      switch (name[3]) {
    75			  case 'D':
    76	          53        if (memEQ(name, "O_RDWR", 6)) {
    77			    /*                  ^        */
    78			#ifdef O_RDWR
    79	          53          *iv_return = O_RDWR;
    80	          53          return PERL_constant_ISIV;
    81			#else
    82			      return PERL_constant_NOTDEF;
    83			#endif
    84			    }
    85	      ######        break;
    86			  case 'E':
    87	      ######        if (memEQ(name, "FCREAT", 6)) {
    88			    /*                  ^        */
    89			#ifdef FCREAT
    90			      *iv_return = FCREAT;
    91			      return PERL_constant_ISIV;
    92			#else
    93	      ######          return PERL_constant_NOTDEF;
    94			#endif
    95			    }
    96	      ######        if (memEQ(name, "O_TEXT", 6)) {
    97			    /*                  ^        */
    98			#ifdef O_TEXT
    99	      ######          *iv_return = O_TEXT;
   100	      ######          return PERL_constant_ISIV;
   101			#else
   102			      return PERL_constant_NOTDEF;
   103			#endif
   104			    }
   105	      ######        break;
   106			  case 'F':
   107	      ######        if (memEQ(name, "FDEFER", 6)) {
   108			    /*                  ^        */
   109			#ifdef FDEFER
   110			      *iv_return = FDEFER;
   111			      return PERL_constant_ISIV;
   112			#else
   113	      ######          return PERL_constant_NOTDEF;
   114			#endif
   115			    }
   116	      ######        break;
   117			  case 'S':
   118	      ######        if (memEQ(name, "O_RSRC", 6)) {
   119			    /*                  ^        */
   120			#ifdef O_RSRC
   121			      *iv_return = O_RSRC;
   122			      return PERL_constant_ISIV;
   123			#else
   124	      ######          return PERL_constant_NOTDEF;
   125			#endif
   126			    }
   127	      ######        break;
   128			  case 'U':
   129	      ######        if (memEQ(name, "FTRUNC", 6)) {
   130			    /*                  ^        */
   131			#ifdef FTRUNC
   132			      *iv_return = FTRUNC;
   133			      return PERL_constant_ISIV;
   134			#else
   135	      ######          return PERL_constant_NOTDEF;
   136			#endif
   137			    }
   138	           6        break;
   139			  case 'X':
   140	           6        if (memEQ(name, "O_EXCL", 6)) {
   141			    /*                  ^        */
   142			#ifdef O_EXCL
   143	           6          *iv_return = O_EXCL;
   144	           6          return PERL_constant_ISIV;
   145			#else
   146			      return PERL_constant_NOTDEF;
   147			#endif
   148			    }
   149	      ######        break;
   150			  case 'Y':
   151	      ######        if (memEQ(name, "FASYNC", 6)) {
   152			    /*                  ^        */
   153			#ifdef FASYNC
   154	      ######          *iv_return = FASYNC;
   155	      ######          return PERL_constant_ISIV;
   156			#else
   157			      return PERL_constant_NOTDEF;
   158			#endif
   159			    }
   160	      ######        if (memEQ(name, "FDSYNC", 6)) {
   161			    /*                  ^        */
   162			#ifdef FDSYNC
   163			      *iv_return = FDSYNC;
   164			      return PERL_constant_ISIV;
   165			#else
   166	      ######          return PERL_constant_NOTDEF;
   167			#endif
   168			    }
   169	      ######        if (memEQ(name, "FRSYNC", 6)) {
   170			    /*                  ^        */
   171			#ifdef FRSYNC
   172			      *iv_return = FRSYNC;
   173			      return PERL_constant_ISIV;
   174			#else
   175	      ######          return PERL_constant_NOTDEF;
   176			#endif
   177			    }
   178	      ######        if (memEQ(name, "O_SYNC", 6)) {
   179			    /*                  ^        */
   180			#ifdef O_SYNC
   181	      ######          *iv_return = O_SYNC;
   182	      ######          return PERL_constant_ISIV;
   183			#else
   184			      return PERL_constant_NOTDEF;
   185			#endif
   186			    }
   187	      ######        break;
   188			  }
   189	      ######      return PERL_constant_NOTFOUND;
   190			}
   191			
   192			static int
   193	          79    constant_7 (pTHX_ const char *name, IV *iv_return) {
   194			  /* When generated this function returned values for the list of names given
   195			     here.  However, subsequent manual editing may have added or removed some.
   196			     FAPPEND FNDELAY F_DUPFD F_EXLCK F_FSYNC F_GETFD F_GETFL F_GETLK F_NODNY
   197			     F_POSIX F_RDACC F_RDDNY F_RDLCK F_RWACC F_RWDNY F_SETFD F_SETFL F_SETLK
   198			     F_SHARE F_SHLCK F_UNLCK F_WRACC F_WRDNY F_WRLCK LOCK_EX LOCK_NB LOCK_RW
   199			     LOCK_SH LOCK_UN O_ALIAS O_ASYNC O_CREAT O_DEFER O_DSYNC O_RSYNC O_TRUNC
   200			     S_ENFMT S_IEXEC S_IFBLK S_IFCHR S_IFDIR S_IFIFO S_IFLNK S_IFREG S_IFWHT
   201			     S_IREAD S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU S_ISGID S_ISTXT
   202			     S_ISUID S_ISVTX S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR _S_IFMT */
   203			  /* Offset 4 gives the best switch position.  */
   204	          79      switch (name[4]) {
   205			  case 'A':
   206	      ######        if (memEQ(name, "F_RDACC", 7)) {
   207			    /*                   ^        */
   208			#ifdef F_RDACC
   209			      *iv_return = F_RDACC;
   210			      return PERL_constant_ISIV;
   211			#else
   212	      ######          return PERL_constant_NOTDEF;
   213			#endif
   214			    }
   215	      ######        if (memEQ(name, "F_RWACC", 7)) {
   216			    /*                   ^        */
   217			#ifdef F_RWACC
   218			      *iv_return = F_RWACC;
   219			      return PERL_constant_ISIV;
   220			#else
   221	      ######          return PERL_constant_NOTDEF;
   222			#endif
   223			    }
   224	      ######        if (memEQ(name, "F_SHARE", 7)) {
   225			    /*                   ^        */
   226			#ifdef F_SHARE
   227			      *iv_return = F_SHARE;
   228			      return PERL_constant_ISIV;
   229			#else
   230	      ######          return PERL_constant_NOTDEF;
   231			#endif
   232			    }
   233	      ######        if (memEQ(name, "F_WRACC", 7)) {
   234			    /*                   ^        */
   235			#ifdef F_WRACC
   236			      *iv_return = F_WRACC;
   237			      return PERL_constant_ISIV;
   238			#else
   239	      ######          return PERL_constant_NOTDEF;
   240			#endif
   241			    }
   242	      ######        break;
   243			  case 'B':
   244	      ######        if (memEQ(name, "S_IFBLK", 7)) {
   245			    /*                   ^        */
   246			#ifdef S_IFBLK
   247	      ######          *iv_return = S_IFBLK;
   248	      ######          return PERL_constant_ISIV;
   249			#else
   250			      return PERL_constant_NOTDEF;
   251			#endif
   252			    }
   253	      ######        break;
   254			  case 'C':
   255	      ######        if (memEQ(name, "S_IFCHR", 7)) {
   256			    /*                   ^        */
   257			#ifdef S_IFCHR
   258	      ######          *iv_return = S_IFCHR;
   259	      ######          return PERL_constant_ISIV;
   260			#else
   261			      return PERL_constant_NOTDEF;
   262			#endif
   263			    }
   264	      ######        break;
   265			  case 'D':
   266	      ######        if (memEQ(name, "F_NODNY", 7)) {
   267			    /*                   ^        */
   268			#ifdef F_NODNY
   269			      *iv_return = F_NODNY;
   270			      return PERL_constant_ISIV;
   271			#else
   272	      ######          return PERL_constant_NOTDEF;
   273			#endif
   274			    }
   275	      ######        if (memEQ(name, "F_RDDNY", 7)) {
   276			    /*                   ^        */
   277			#ifdef F_RDDNY
   278			      *iv_return = F_RDDNY;
   279			      return PERL_constant_ISIV;
   280			#else
   281	      ######          return PERL_constant_NOTDEF;
   282			#endif
   283			    }
   284	      ######        if (memEQ(name, "F_RWDNY", 7)) {
   285			    /*                   ^        */
   286			#ifdef F_RWDNY
   287			      *iv_return = F_RWDNY;
   288			      return PERL_constant_ISIV;
   289			#else
   290	      ######          return PERL_constant_NOTDEF;
   291			#endif
   292			    }
   293	      ######        if (memEQ(name, "F_WRDNY", 7)) {
   294			    /*                   ^        */
   295			#ifdef F_WRDNY
   296			      *iv_return = F_WRDNY;
   297			      return PERL_constant_ISIV;
   298			#else
   299	      ######          return PERL_constant_NOTDEF;
   300			#endif
   301			    }
   302	      ######        if (memEQ(name, "S_IFDIR", 7)) {
   303			    /*                   ^        */
   304			#ifdef S_IFDIR
   305	      ######          *iv_return = S_IFDIR;
   306	      ######          return PERL_constant_ISIV;
   307			#else
   308			      return PERL_constant_NOTDEF;
   309			#endif
   310			    }
   311	          55        break;
   312			  case 'E':
   313	          55        if (memEQ(name, "FAPPEND", 7)) {
   314			    /*                   ^        */
   315			#ifdef FAPPEND
   316	      ######          *iv_return = FAPPEND;
   317	      ######          return PERL_constant_ISIV;
   318			#else
   319			      return PERL_constant_NOTDEF;
   320			#endif
   321			    }
   322	          55        if (memEQ(name, "O_CREAT", 7)) {
   323			    /*                   ^        */
   324			#ifdef O_CREAT
   325	          55          *iv_return = O_CREAT;
   326	          55          return PERL_constant_ISIV;
   327			#else
   328			      return PERL_constant_NOTDEF;
   329			#endif
   330			    }
   331	      ######        if (memEQ(name, "S_IREAD", 7)) {
   332			    /*                   ^        */
   333			#ifdef S_IREAD
   334	      ######          *iv_return = S_IREAD;
   335	      ######          return PERL_constant_ISIV;
   336			#else
   337			      return PERL_constant_NOTDEF;
   338			#endif
   339			    }
   340	      ######        break;
   341			  case 'F':
   342	      ######        if (memEQ(name, "O_DEFER", 7)) {
   343			    /*                   ^        */
   344			#ifdef O_DEFER
   345			      *iv_return = O_DEFER;
   346			      return PERL_constant_ISIV;
   347			#else
   348	      ######          return PERL_constant_NOTDEF;
   349			#endif
   350			    }
   351	      ######        if (memEQ(name, "S_ENFMT", 7)) {
   352			    /*                   ^        */
   353			#ifdef S_ENFMT
   354			      *iv_return = S_ENFMT;
   355			      return PERL_constant_ISIV;
   356			#else
   357	      ######          return PERL_constant_NOTDEF;
   358			#endif
   359			    }
   360	      ######        if (memEQ(name, "_S_IFMT", 7)) {
   361			    /*                   ^        */
   362			#ifdef S_IFMT
   363	      ######          *iv_return = S_IFMT;
   364	      ######          return PERL_constant_ISIV;
   365			#else
   366			      return PERL_constant_NOTDEF;
   367			#endif
   368			    }
   369	           1        break;
   370			  case 'G':
   371	           1        if (memEQ(name, "S_IRGRP", 7)) {
   372			    /*                   ^        */
   373			#ifdef S_IRGRP
   374	      ######          *iv_return = S_IRGRP;
   375	      ######          return PERL_constant_ISIV;
   376			#else
   377			      return PERL_constant_NOTDEF;
   378			#endif
   379			    }
   380	           1        if (memEQ(name, "S_ISGID", 7)) {
   381			    /*                   ^        */
   382			#ifdef S_ISGID
   383	      ######          *iv_return = S_ISGID;
   384	      ######          return PERL_constant_ISIV;
   385			#else
   386			      return PERL_constant_NOTDEF;
   387			#endif
   388			    }
   389	           1        if (memEQ(name, "S_IWGRP", 7)) {
   390			    /*                   ^        */
   391			#ifdef S_IWGRP
   392	           1          *iv_return = S_IWGRP;
   393	           1          return PERL_constant_ISIV;
   394			#else
   395			      return PERL_constant_NOTDEF;
   396			#endif
   397			    }
   398	      ######        if (memEQ(name, "S_IXGRP", 7)) {
   399			    /*                   ^        */
   400			#ifdef S_IXGRP
   401	      ######          *iv_return = S_IXGRP;
   402	      ######          return PERL_constant_ISIV;
   403			#else
   404			      return PERL_constant_NOTDEF;
   405			#endif
   406			    }
   407	      ######        break;
   408			  case 'I':
   409	      ######        if (memEQ(name, "O_ALIAS", 7)) {
   410			    /*                   ^        */
   411			#ifdef O_ALIAS
   412			      *iv_return = O_ALIAS;
   413			      return PERL_constant_ISIV;
   414			#else
   415	      ######          return PERL_constant_NOTDEF;
   416			#endif
   417			    }
   418	      ######        if (memEQ(name, "S_IFIFO", 7)) {
   419			    /*                   ^        */
   420			#ifdef S_IFIFO
   421	      ######          *iv_return = S_IFIFO;
   422	      ######          return PERL_constant_ISIV;
   423			#else
   424			      return PERL_constant_NOTDEF;
   425			#endif
   426			    }
   427	      ######        break;
   428			  case 'L':
   429	      ######        if (memEQ(name, "FNDELAY", 7)) {
   430			    /*                   ^        */
   431			#ifdef FNDELAY
   432	      ######          *iv_return = FNDELAY;
   433	      ######          return PERL_constant_ISIV;
   434			#else
   435			      return PERL_constant_NOTDEF;
   436			#endif
   437			    }
   438	      ######        if (memEQ(name, "F_EXLCK", 7)) {
   439			    /*                   ^        */
   440			#ifdef F_EXLCK
   441	      ######          *iv_return = F_EXLCK;
   442	      ######          return PERL_constant_ISIV;
   443			#else
   444			      return PERL_constant_NOTDEF;
   445			#endif
   446			    }
   447	      ######        if (memEQ(name, "F_RDLCK", 7)) {
   448			    /*                   ^        */
   449			#ifdef F_RDLCK
   450	      ######          *iv_return = F_RDLCK;
   451	      ######          return PERL_constant_ISIV;
   452			#else
   453			      return PERL_constant_NOTDEF;
   454			#endif
   455			    }
   456	      ######        if (memEQ(name, "F_SHLCK", 7)) {
   457			    /*                   ^        */
   458			#ifdef F_SHLCK
   459	      ######          *iv_return = F_SHLCK;
   460	      ######          return PERL_constant_ISIV;
   461			#else
   462			      return PERL_constant_NOTDEF;
   463			#endif
   464			    }
   465	      ######        if (memEQ(name, "F_UNLCK", 7)) {
   466			    /*                   ^        */
   467			#ifdef F_UNLCK
   468	      ######          *iv_return = F_UNLCK;
   469	      ######          return PERL_constant_ISIV;
   470			#else
   471			      return PERL_constant_NOTDEF;
   472			#endif
   473			    }
   474	      ######        if (memEQ(name, "F_WRLCK", 7)) {
   475			    /*                   ^        */
   476			#ifdef F_WRLCK
   477	      ######          *iv_return = F_WRLCK;
   478	      ######          return PERL_constant_ISIV;
   479			#else
   480			      return PERL_constant_NOTDEF;
   481			#endif
   482			    }
   483	      ######        if (memEQ(name, "S_IFLNK", 7)) {
   484			    /*                   ^        */
   485			#ifdef S_IFLNK
   486	      ######          *iv_return = S_IFLNK;
   487	      ######          return PERL_constant_ISIV;
   488			#else
   489			      return PERL_constant_NOTDEF;
   490			#endif
   491			    }
   492	           1        break;
   493			  case 'O':
   494	           1        if (memEQ(name, "S_IROTH", 7)) {
   495			    /*                   ^        */
   496			#ifdef S_IROTH
   497	      ######          *iv_return = S_IROTH;
   498	      ######          return PERL_constant_ISIV;
   499			#else
   500			      return PERL_constant_NOTDEF;
   501			#endif
   502			    }
   503	           1        if (memEQ(name, "S_IWOTH", 7)) {
   504			    /*                   ^        */
   505			#ifdef S_IWOTH
   506	           1          *iv_return = S_IWOTH;
   507	           1          return PERL_constant_ISIV;
   508			#else
   509			      return PERL_constant_NOTDEF;
   510			#endif
   511			    }
   512	      ######        if (memEQ(name, "S_IXOTH", 7)) {
   513			    /*                   ^        */
   514			#ifdef S_IXOTH
   515	      ######          *iv_return = S_IXOTH;
   516	      ######          return PERL_constant_ISIV;
   517			#else
   518			      return PERL_constant_NOTDEF;
   519			#endif
   520			    }
   521	      ######        break;
   522			  case 'P':
   523	      ######        if (memEQ(name, "F_DUPFD", 7)) {
   524			    /*                   ^        */
   525			#ifdef F_DUPFD
   526	      ######          *iv_return = F_DUPFD;
   527	      ######          return PERL_constant_ISIV;
   528			#else
   529			      return PERL_constant_NOTDEF;
   530			#endif
   531			    }
   532	      ######        break;
   533			  case 'R':
   534	      ######        if (memEQ(name, "S_IFREG", 7)) {
   535			    /*                   ^        */
   536			#ifdef S_IFREG
   537	      ######          *iv_return = S_IFREG;
   538	      ######          return PERL_constant_ISIV;
   539			#else
   540			      return PERL_constant_NOTDEF;
   541			#endif
   542			    }
   543	      ######        break;
   544			  case 'S':
   545	      ######        if (memEQ(name, "F_POSIX", 7)) {
   546			    /*                   ^        */
   547			#ifdef F_POSIX
   548			      *iv_return = F_POSIX;
   549			      return PERL_constant_ISIV;
   550			#else
   551	      ######          return PERL_constant_NOTDEF;
   552			#endif
   553			    }
   554	           4        break;
   555			  case 'T':
   556	           4        if (memEQ(name, "F_GETFD", 7)) {
   557			    /*                   ^        */
   558			#ifdef F_GETFD
   559	      ######          *iv_return = F_GETFD;
   560	      ######          return PERL_constant_ISIV;
   561			#else
   562			      return PERL_constant_NOTDEF;
   563			#endif
   564			    }
   565	           4        if (memEQ(name, "F_GETFL", 7)) {
   566			    /*                   ^        */
   567			#ifdef F_GETFL
   568	           2          *iv_return = F_GETFL;
   569	           2          return PERL_constant_ISIV;
   570			#else
   571			      return PERL_constant_NOTDEF;
   572			#endif
   573			    }
   574	           2        if (memEQ(name, "F_GETLK", 7)) {
   575			    /*                   ^        */
   576			#ifdef F_GETLK
   577	      ######          *iv_return = F_GETLK;
   578	      ######          return PERL_constant_ISIV;
   579			#else
   580			      return PERL_constant_NOTDEF;
   581			#endif
   582			    }
   583	           2        if (memEQ(name, "F_SETFD", 7)) {
   584			    /*                   ^        */
   585			#ifdef F_SETFD
   586	      ######          *iv_return = F_SETFD;
   587	      ######          return PERL_constant_ISIV;
   588			#else
   589			      return PERL_constant_NOTDEF;
   590			#endif
   591			    }
   592	           2        if (memEQ(name, "F_SETFL", 7)) {
   593			    /*                   ^        */
   594			#ifdef F_SETFL
   595	           2          *iv_return = F_SETFL;
   596	           2          return PERL_constant_ISIV;
   597			#else
   598			      return PERL_constant_NOTDEF;
   599			#endif
   600			    }
   601	      ######        if (memEQ(name, "F_SETLK", 7)) {
   602			    /*                   ^        */
   603			#ifdef F_SETLK
   604	      ######          *iv_return = F_SETLK;
   605	      ######          return PERL_constant_ISIV;
   606			#else
   607			      return PERL_constant_NOTDEF;
   608			#endif
   609			    }
   610	      ######        if (memEQ(name, "S_ISTXT", 7)) {
   611			    /*                   ^        */
   612			#ifdef S_ISTXT
   613			      *iv_return = S_ISTXT;
   614			      return PERL_constant_ISIV;
   615			#else
   616	      ######          return PERL_constant_NOTDEF;
   617			#endif
   618			    }
   619	           3        break;
   620			  case 'U':
   621	           3        if (memEQ(name, "O_TRUNC", 7)) {
   622			    /*                   ^        */
   623			#ifdef O_TRUNC
   624	           3          *iv_return = O_TRUNC;
   625	           3          return PERL_constant_ISIV;
   626			#else
   627			      return PERL_constant_NOTDEF;
   628			#endif
   629			    }
   630	      ######        if (memEQ(name, "S_IRUSR", 7)) {
   631			    /*                   ^        */
   632			#ifdef S_IRUSR
   633	      ######          *iv_return = S_IRUSR;
   634	      ######          return PERL_constant_ISIV;
   635			#else
   636			      return PERL_constant_NOTDEF;
   637			#endif
   638			    }
   639	      ######        if (memEQ(name, "S_ISUID", 7)) {
   640			    /*                   ^        */
   641			#ifdef S_ISUID
   642	      ######          *iv_return = S_ISUID;
   643	      ######          return PERL_constant_ISIV;
   644			#else
   645			      return PERL_constant_NOTDEF;
   646			#endif
   647			    }
   648	      ######        if (memEQ(name, "S_IWUSR", 7)) {
   649			    /*                   ^        */
   650			#ifdef S_IWUSR
   651	      ######          *iv_return = S_IWUSR;
   652	      ######          return PERL_constant_ISIV;
   653			#else
   654			      return PERL_constant_NOTDEF;
   655			#endif
   656			    }
   657	      ######        if (memEQ(name, "S_IXUSR", 7)) {
   658			    /*                   ^        */
   659			#ifdef S_IXUSR
   660	      ######          *iv_return = S_IXUSR;
   661	      ######          return PERL_constant_ISIV;
   662			#else
   663			      return PERL_constant_NOTDEF;
   664			#endif
   665			    }
   666	      ######        break;
   667			  case 'V':
   668	      ######        if (memEQ(name, "S_ISVTX", 7)) {
   669			    /*                   ^        */
   670			#ifdef S_ISVTX
   671	      ######          *iv_return = S_ISVTX;
   672	      ######          return PERL_constant_ISIV;
   673			#else
   674			      return PERL_constant_NOTDEF;
   675			#endif
   676			    }
   677	      ######        break;
   678			  case 'W':
   679	      ######        if (memEQ(name, "S_IFWHT", 7)) {
   680			    /*                   ^        */
   681			#ifdef S_IFWHT
   682			      *iv_return = S_IFWHT;
   683			      return PERL_constant_ISIV;
   684			#else
   685	      ######          return PERL_constant_NOTDEF;
   686			#endif
   687			    }
   688	      ######        if (memEQ(name, "S_IRWXG", 7)) {
   689			    /*                   ^        */
   690			#ifdef S_IRWXG
   691	      ######          *iv_return = S_IRWXG;
   692	      ######          return PERL_constant_ISIV;
   693			#else
   694			      return PERL_constant_NOTDEF;
   695			#endif
   696			    }
   697	      ######        if (memEQ(name, "S_IRWXO", 7)) {
   698			    /*                   ^        */
   699			#ifdef S_IRWXO
   700	      ######          *iv_return = S_IRWXO;
   701	      ######          return PERL_constant_ISIV;
   702			#else
   703			      return PERL_constant_NOTDEF;
   704			#endif
   705			    }
   706	      ######        if (memEQ(name, "S_IRWXU", 7)) {
   707			    /*                   ^        */
   708			#ifdef S_IRWXU
   709	      ######          *iv_return = S_IRWXU;
   710	      ######          return PERL_constant_ISIV;
   711			#else
   712			      return PERL_constant_NOTDEF;
   713			#endif
   714			    }
   715	      ######        break;
   716			  case 'X':
   717	      ######        if (memEQ(name, "S_IEXEC", 7)) {
   718			    /*                   ^        */
   719			#ifdef S_IEXEC
   720	      ######          *iv_return = S_IEXEC;
   721	      ######          return PERL_constant_ISIV;
   722			#else
   723			      return PERL_constant_NOTDEF;
   724			#endif
   725			    }
   726	      ######        break;
   727			  case 'Y':
   728	      ######        if (memEQ(name, "F_FSYNC", 7)) {
   729			    /*                   ^        */
   730			#ifdef F_FSYNC
   731			      *iv_return = F_FSYNC;
   732			      return PERL_constant_ISIV;
   733			#else
   734	      ######          return PERL_constant_NOTDEF;
   735			#endif
   736			    }
   737	      ######        if (memEQ(name, "O_ASYNC", 7)) {
   738			    /*                   ^        */
   739			#ifdef O_ASYNC
   740	      ######          *iv_return = O_ASYNC;
   741	      ######          return PERL_constant_ISIV;
   742			#else
   743			      return PERL_constant_NOTDEF;
   744			#endif
   745			    }
   746	      ######        if (memEQ(name, "O_DSYNC", 7)) {
   747			    /*                   ^        */
   748			#ifdef O_DSYNC
   749	      ######          *iv_return = O_DSYNC;
   750	      ######          return PERL_constant_ISIV;
   751			#else
   752			      return PERL_constant_NOTDEF;
   753			#endif
   754			    }
   755	      ######        if (memEQ(name, "O_RSYNC", 7)) {
   756			    /*                   ^        */
   757			#ifdef O_RSYNC
   758	      ######          *iv_return = O_RSYNC;
   759	      ######          return PERL_constant_ISIV;
   760			#else
   761			      return PERL_constant_NOTDEF;
   762			#endif
   763			    }
   764	          15        break;
   765			  case '_':
   766	          15        if (memEQ(name, "LOCK_EX", 7)) {
   767			    /*                   ^        */
   768			#ifdef LOCK_EX
   769	           2          *iv_return = LOCK_EX;
   770	           2          return PERL_constant_ISIV;
   771			#else
   772			      *iv_return = 2;
   773			      return PERL_constant_ISIV;
   774			#endif
   775			    }
   776	          13        if (memEQ(name, "LOCK_NB", 7)) {
   777			    /*                   ^        */
   778			#ifdef LOCK_NB
   779	      ######          *iv_return = LOCK_NB;
   780	      ######          return PERL_constant_ISIV;
   781			#else
   782			      *iv_return = 4;
   783			      return PERL_constant_ISIV;
   784			#endif
   785			    }
   786	          13        if (memEQ(name, "LOCK_RW", 7)) {
   787			    /*                   ^        */
   788			#ifdef LOCK_RW
   789	      ######          *iv_return = LOCK_RW;
   790	      ######          return PERL_constant_ISIV;
   791			#else
   792			      return PERL_constant_NOTDEF;
   793			#endif
   794			    }
   795	          13        if (memEQ(name, "LOCK_SH", 7)) {
   796			    /*                   ^        */
   797			#ifdef LOCK_SH
   798	          12          *iv_return = LOCK_SH;
   799	          12          return PERL_constant_ISIV;
   800			#else
   801			      *iv_return = 1;
   802			      return PERL_constant_ISIV;
   803			#endif
   804			    }
   805	           1        if (memEQ(name, "LOCK_UN", 7)) {
   806			    /*                   ^        */
   807			#ifdef LOCK_UN
   808	           1          *iv_return = LOCK_UN;
   809	           1          return PERL_constant_ISIV;
   810			#else
   811			      *iv_return = 8;
   812			      return PERL_constant_ISIV;
   813			#endif
   814			    }
   815	      ######        break;
   816			  }
   817	      ######      return PERL_constant_NOTFOUND;
   818			}
   819			
   820			static int
   821	          98    constant_8 (pTHX_ const char *name, IV *iv_return) {
   822			  /* When generated this function returned values for the list of names given
   823			     here.  However, subsequent manual editing may have added or removed some.
   824			     F_COMPAT F_DUP2FD F_FREESP F_GETOWN F_GETSIG F_NOTIFY F_SETLKW F_SETOWN
   825			     F_SETSIG O_APPEND O_BINARY O_DIRECT O_EXLOCK O_NDELAY O_NOCTTY O_NOLINK
   826			     O_RANDOM O_RDONLY O_SHLOCK O_WRONLY SEEK_CUR SEEK_END SEEK_SET S_IFSOCK
   827			     S_IWRITE */
   828			  /* Offset 6 gives the best switch position.  */
   829	          98      switch (name[6]) {
   830			  case 'A':
   831	      ######        if (memEQ(name, "F_COMPAT", 8)) {
   832			    /*                     ^       */
   833			#ifdef F_COMPAT
   834			      *iv_return = F_COMPAT;
   835			      return PERL_constant_ISIV;
   836			#else
   837	      ######          return PERL_constant_NOTDEF;
   838			#endif
   839			    }
   840	      ######        if (memEQ(name, "O_NDELAY", 8)) {
   841			    /*                     ^       */
   842			#ifdef O_NDELAY
   843	      ######          *iv_return = O_NDELAY;
   844	      ######          return PERL_constant_ISIV;
   845			#else
   846			      return PERL_constant_NOTDEF;
   847			#endif
   848			    }
   849	           6        break;
   850			  case 'C':
   851	           6        if (memEQ(name, "O_DIRECT", 8)) {
   852			    /*                     ^       */
   853			#ifdef O_DIRECT
   854	      ######          *iv_return = O_DIRECT;
   855	      ######          return PERL_constant_ISIV;
   856			#else
   857			      return PERL_constant_NOTDEF;
   858			#endif
   859			    }
   860	           6        if (memEQ(name, "O_EXLOCK", 8)) {
   861			    /*                     ^       */
   862			#ifdef O_EXLOCK
   863			      *iv_return = O_EXLOCK;
   864			      return PERL_constant_ISIV;
   865			#else
   866	           6          return PERL_constant_NOTDEF;
   867			#endif
   868			    }
   869	      ######        if (memEQ(name, "O_SHLOCK", 8)) {
   870			    /*                     ^       */
   871			#ifdef O_SHLOCK
   872			      *iv_return = O_SHLOCK;
   873			      return PERL_constant_ISIV;
   874			#else
   875	      ######          return PERL_constant_NOTDEF;
   876			#endif
   877			    }
   878	      ######        if (memEQ(name, "S_IFSOCK", 8)) {
   879			    /*                     ^       */
   880			#ifdef S_IFSOCK
   881	      ######          *iv_return = S_IFSOCK;
   882	      ######          return PERL_constant_ISIV;
   883			#else
   884			      return PERL_constant_NOTDEF;
   885			#endif
   886			    }
   887	           5        break;
   888			  case 'E':
   889	           5        if (memEQ(name, "SEEK_SET", 8)) {
   890			    /*                     ^       */
   891			#ifdef SEEK_SET
   892	           5          *iv_return = SEEK_SET;
   893	           5          return PERL_constant_ISIV;
   894			#else
   895			      *iv_return = 0;
   896			      return PERL_constant_ISIV;
   897			#endif
   898			    }
   899	      ######        break;
   900			  case 'F':
   901	      ######        if (memEQ(name, "F_DUP2FD", 8)) {
   902			    /*                     ^       */
   903			#ifdef F_DUP2FD
   904			      *iv_return = F_DUP2FD;
   905			      return PERL_constant_ISIV;
   906			#else
   907	      ######          return PERL_constant_NOTDEF;
   908			#endif
   909			    }
   910	      ######        if (memEQ(name, "F_NOTIFY", 8)) {
   911			    /*                     ^       */
   912			#ifdef F_NOTIFY
   913	      ######          *iv_return = F_NOTIFY;
   914	      ######          return PERL_constant_ISIV;
   915			#else
   916			      return PERL_constant_NOTDEF;
   917			#endif
   918			    }
   919	      ######        break;
   920			  case 'I':
   921	      ######        if (memEQ(name, "F_GETSIG", 8)) {
   922			    /*                     ^       */
   923			#ifdef F_GETSIG
   924	      ######          *iv_return = F_GETSIG;
   925	      ######          return PERL_constant_ISIV;
   926			#else
   927			      return PERL_constant_NOTDEF;
   928			#endif
   929			    }
   930	      ######        if (memEQ(name, "F_SETSIG", 8)) {
   931			    /*                     ^       */
   932			#ifdef F_SETSIG
   933	      ######          *iv_return = F_SETSIG;
   934	      ######          return PERL_constant_ISIV;
   935			#else
   936			      return PERL_constant_NOTDEF;
   937			#endif
   938			    }
   939	      ######        break;
   940			  case 'K':
   941	      ######        if (memEQ(name, "F_SETLKW", 8)) {
   942			    /*                     ^       */
   943			#ifdef F_SETLKW
   944	      ######          *iv_return = F_SETLKW;
   945	      ######          return PERL_constant_ISIV;
   946			#else
   947			      return PERL_constant_NOTDEF;
   948			#endif
   949			    }
   950	          77        break;
   951			  case 'L':
   952	          77        if (memEQ(name, "O_RDONLY", 8)) {
   953			    /*                     ^       */
   954			#ifdef O_RDONLY
   955	          39          *iv_return = O_RDONLY;
   956	          39          return PERL_constant_ISIV;
   957			#else
   958			      return PERL_constant_NOTDEF;
   959			#endif
   960			    }
   961	          38        if (memEQ(name, "O_WRONLY", 8)) {
   962			    /*                     ^       */
   963			#ifdef O_WRONLY
   964	          38          *iv_return = O_WRONLY;
   965	          38          return PERL_constant_ISIV;
   966			#else
   967			      return PERL_constant_NOTDEF;
   968			#endif
   969			    }
   970	           2        break;
   971			  case 'N':
   972	           2        if (memEQ(name, "O_APPEND", 8)) {
   973			    /*                     ^       */
   974			#ifdef O_APPEND
   975	           1          *iv_return = O_APPEND;
   976	           1          return PERL_constant_ISIV;
   977			#else
   978			      return PERL_constant_NOTDEF;
   979			#endif
   980			    }
   981	           1        if (memEQ(name, "O_NOLINK", 8)) {
   982			    /*                     ^       */
   983			#ifdef O_NOLINK
   984			      *iv_return = O_NOLINK;
   985			      return PERL_constant_ISIV;
   986			#else
   987	      ######          return PERL_constant_NOTDEF;
   988			#endif
   989			    }
   990	           1        if (memEQ(name, "SEEK_END", 8)) {
   991			    /*                     ^       */
   992			#ifdef SEEK_END
   993	           1          *iv_return = SEEK_END;
   994	           1          return PERL_constant_ISIV;
   995			#else
   996			      *iv_return = 2;
   997			      return PERL_constant_ISIV;
   998			#endif
   999			    }
  1000	      ######        break;
  1001			  case 'O':
  1002	      ######        if (memEQ(name, "O_RANDOM", 8)) {
  1003			    /*                     ^       */
  1004			#ifdef O_RANDOM
  1005			      *iv_return = O_RANDOM;
  1006			      return PERL_constant_ISIV;
  1007			#else
  1008	      ######          return PERL_constant_NOTDEF;
  1009			#endif
  1010			    }
  1011	           6        break;
  1012			  case 'R':
  1013	           6        if (memEQ(name, "O_BINARY", 8)) {
  1014			    /*                     ^       */
  1015			#ifdef O_BINARY
  1016	           6          *iv_return = O_BINARY;
  1017	           6          return PERL_constant_ISIV;
  1018			#else
  1019			      return PERL_constant_NOTDEF;
  1020			#endif
  1021			    }
  1022	      ######        break;
  1023			  case 'S':
  1024	      ######        if (memEQ(name, "F_FREESP", 8)) {
  1025			    /*                     ^       */
  1026			#ifdef F_FREESP
  1027			      *iv_return = F_FREESP;
  1028			      return PERL_constant_ISIV;
  1029			#else
  1030	      ######          return PERL_constant_NOTDEF;
  1031			#endif
  1032			    }
  1033	      ######        break;
  1034			  case 'T':
  1035	      ######        if (memEQ(name, "O_NOCTTY", 8)) {
  1036			    /*                     ^       */
  1037			#ifdef O_NOCTTY
  1038	      ######          *iv_return = O_NOCTTY;
  1039	      ######          return PERL_constant_ISIV;
  1040			#else
  1041			      return PERL_constant_NOTDEF;
  1042			#endif
  1043			    }
  1044	      ######        if (memEQ(name, "S_IWRITE", 8)) {
  1045			    /*                     ^       */
  1046			#ifdef S_IWRITE
  1047	      ######          *iv_return = S_IWRITE;
  1048	      ######          return PERL_constant_ISIV;
  1049			#else
  1050			      return PERL_constant_NOTDEF;
  1051			#endif
  1052			    }
  1053	           2        break;
  1054			  case 'U':
  1055	           2        if (memEQ(name, "SEEK_CUR", 8)) {
  1056			    /*                     ^       */
  1057			#ifdef SEEK_CUR
  1058	           2          *iv_return = SEEK_CUR;
  1059	           2          return PERL_constant_ISIV;
  1060			#else
  1061			      *iv_return = 1;
  1062			      return PERL_constant_ISIV;
  1063			#endif
  1064			    }
  1065	      ######        break;
  1066			  case 'W':
  1067	      ######        if (memEQ(name, "F_GETOWN", 8)) {
  1068			    /*                     ^       */
  1069			#ifdef F_GETOWN
  1070	      ######          *iv_return = F_GETOWN;
  1071	      ######          return PERL_constant_ISIV;
  1072			#else
  1073			      return PERL_constant_NOTDEF;
  1074			#endif
  1075			    }
  1076	      ######        if (memEQ(name, "F_SETOWN", 8)) {
  1077			    /*                     ^       */
  1078			#ifdef F_SETOWN
  1079	      ######          *iv_return = F_SETOWN;
  1080	      ######          return PERL_constant_ISIV;
  1081			#else
  1082			      return PERL_constant_NOTDEF;
  1083			#endif
  1084			    }
  1085	      ######        break;
  1086			  }
  1087	      ######      return PERL_constant_NOTFOUND;
  1088			}
  1089			
  1090			static int
  1091	      ######    constant_9 (pTHX_ const char *name, IV *iv_return) {
  1092			  /* When generated this function returned values for the list of names given
  1093			     here.  However, subsequent manual editing may have added or removed some.
  1094			     DN_ACCESS DN_ATTRIB DN_CREATE DN_DELETE DN_MODIFY DN_RENAME FNONBLOCK
  1095			     F_ALLOCSP F_FSYNC64 F_GETLK64 F_SETLK64 F_UNSHARE LOCK_MAND LOCK_READ
  1096			     O_ACCMODE O_NOATIME O_NOTRANS */
  1097			  /* Offset 3 gives the best switch position.  */
  1098	      ######      switch (name[3]) {
  1099			  case 'A':
  1100	      ######        if (memEQ(name, "DN_ACCESS", 9)) {
  1101			    /*                  ^           */
  1102			#ifdef DN_ACCESS
  1103	      ######          *iv_return = DN_ACCESS;
  1104	      ######          return PERL_constant_ISIV;
  1105			#else
  1106			      return PERL_constant_NOTDEF;
  1107			#endif
  1108			    }
  1109	      ######        if (memEQ(name, "DN_ATTRIB", 9)) {
  1110			    /*                  ^           */
  1111			#ifdef DN_ATTRIB
  1112	      ######          *iv_return = DN_ATTRIB;
  1113	      ######          return PERL_constant_ISIV;
  1114			#else
  1115			      return PERL_constant_NOTDEF;
  1116			#endif
  1117			    }
  1118	      ######        break;
  1119			  case 'C':
  1120	      ######        if (memEQ(name, "DN_CREATE", 9)) {
  1121			    /*                  ^           */
  1122			#ifdef DN_CREATE
  1123	      ######          *iv_return = DN_CREATE;
  1124	      ######          return PERL_constant_ISIV;
  1125			#else
  1126			      return PERL_constant_NOTDEF;
  1127			#endif
  1128			    }
  1129	      ######        if (memEQ(name, "O_ACCMODE", 9)) {
  1130			    /*                  ^           */
  1131			#ifdef O_ACCMODE
  1132	      ######          *iv_return = O_ACCMODE;
  1133	      ######          return PERL_constant_ISIV;
  1134			#else
  1135			      return PERL_constant_NOTDEF;
  1136			#endif
  1137			    }
  1138	      ######        break;
  1139			  case 'D':
  1140	      ######        if (memEQ(name, "DN_DELETE", 9)) {
  1141			    /*                  ^           */
  1142			#ifdef DN_DELETE
  1143	      ######          *iv_return = DN_DELETE;
  1144	      ######          return PERL_constant_ISIV;
  1145			#else
  1146			      return PERL_constant_NOTDEF;
  1147			#endif
  1148			    }
  1149	      ######        break;
  1150			  case 'E':
  1151	      ######        if (memEQ(name, "F_GETLK64", 9)) {
  1152			    /*                  ^           */
  1153			#ifdef F_GETLK64
  1154	      ######          *iv_return = F_GETLK64;
  1155	      ######          return PERL_constant_ISIV;
  1156			#else
  1157			      return PERL_constant_NOTDEF;
  1158			#endif
  1159			    }
  1160	      ######        if (memEQ(name, "F_SETLK64", 9)) {
  1161			    /*                  ^           */
  1162			#ifdef F_SETLK64
  1163	      ######          *iv_return = F_SETLK64;
  1164	      ######          return PERL_constant_ISIV;
  1165			#else
  1166			      return PERL_constant_NOTDEF;
  1167			#endif
  1168			    }
  1169	      ######        break;
  1170			  case 'K':
  1171	      ######        if (memEQ(name, "LOCK_MAND", 9)) {
  1172			    /*                  ^           */
  1173			#ifdef LOCK_MAND
  1174	      ######          *iv_return = LOCK_MAND;
  1175	      ######          return PERL_constant_ISIV;
  1176			#else
  1177			      return PERL_constant_NOTDEF;
  1178			#endif
  1179			    }
  1180	      ######        if (memEQ(name, "LOCK_READ", 9)) {
  1181			    /*                  ^           */
  1182			#ifdef LOCK_READ
  1183	      ######          *iv_return = LOCK_READ;
  1184	      ######          return PERL_constant_ISIV;
  1185			#else
  1186			      return PERL_constant_NOTDEF;
  1187			#endif
  1188			    }
  1189	      ######        break;
  1190			  case 'L':
  1191	      ######        if (memEQ(name, "F_ALLOCSP", 9)) {
  1192			    /*                  ^           */
  1193			#ifdef F_ALLOCSP
  1194			      *iv_return = F_ALLOCSP;
  1195			      return PERL_constant_ISIV;
  1196			#else
  1197	      ######          return PERL_constant_NOTDEF;
  1198			#endif
  1199			    }
  1200	      ######        break;
  1201			  case 'M':
  1202	      ######        if (memEQ(name, "DN_MODIFY", 9)) {
  1203			    /*                  ^           */
  1204			#ifdef DN_MODIFY
  1205	      ######          *iv_return = DN_MODIFY;
  1206	      ######          return PERL_constant_ISIV;
  1207			#else
  1208			      return PERL_constant_NOTDEF;
  1209			#endif
  1210			    }
  1211	      ######        break;
  1212			  case 'N':
  1213	      ######        if (memEQ(name, "FNONBLOCK", 9)) {
  1214			    /*                  ^           */
  1215			#ifdef FNONBLOCK
  1216	      ######          *iv_return = FNONBLOCK;
  1217	      ######          return PERL_constant_ISIV;
  1218			#else
  1219			      return PERL_constant_NOTDEF;
  1220			#endif
  1221			    }
  1222	      ######        if (memEQ(name, "F_UNSHARE", 9)) {
  1223			    /*                  ^           */
  1224			#ifdef F_UNSHARE
  1225			      *iv_return = F_UNSHARE;
  1226			      return PERL_constant_ISIV;
  1227			#else
  1228	      ######          return PERL_constant_NOTDEF;
  1229			#endif
  1230			    }
  1231	      ######        break;
  1232			  case 'O':
  1233	      ######        if (memEQ(name, "O_NOATIME", 9)) {
  1234			    /*                  ^           */
  1235			#ifdef O_NOATIME
  1236			      *iv_return = O_NOATIME;
  1237			      return PERL_constant_ISIV;
  1238			#else
  1239	      ######          return PERL_constant_NOTDEF;
  1240			#endif
  1241			    }
  1242	      ######        if (memEQ(name, "O_NOTRANS", 9)) {
  1243			    /*                  ^           */
  1244			#ifdef O_NOTRANS
  1245			      *iv_return = O_NOTRANS;
  1246			      return PERL_constant_ISIV;
  1247			#else
  1248	      ######          return PERL_constant_NOTDEF;
  1249			#endif
  1250			    }
  1251	      ######        break;
  1252			  case 'R':
  1253	      ######        if (memEQ(name, "DN_RENAME", 9)) {
  1254			    /*                  ^           */
  1255			#ifdef DN_RENAME
  1256	      ######          *iv_return = DN_RENAME;
  1257	      ######          return PERL_constant_ISIV;
  1258			#else
  1259			      return PERL_constant_NOTDEF;
  1260			#endif
  1261			    }
  1262	      ######        break;
  1263			  case 'S':
  1264	      ######        if (memEQ(name, "F_FSYNC64", 9)) {
  1265			    /*                  ^           */
  1266			#ifdef F_FSYNC64
  1267			      *iv_return = F_FSYNC64;
  1268			      return PERL_constant_ISIV;
  1269			#else
  1270	      ######          return PERL_constant_NOTDEF;
  1271			#endif
  1272			    }
  1273	      ######        break;
  1274			  }
  1275	      ######      return PERL_constant_NOTFOUND;
  1276			}
  1277			
  1278			static int
  1279	           8    constant_10 (pTHX_ const char *name, IV *iv_return) {
  1280			  /* When generated this function returned values for the list of names given
  1281			     here.  However, subsequent manual editing may have added or removed some.
  1282			     FD_CLOEXEC FLARGEFILE F_FREESP64 F_GETLEASE F_SETLEASE F_SETLKW64
  1283			     LOCK_WRITE O_NOFOLLOW O_NONBLOCK */
  1284			  /* Offset 7 gives the best switch position.  */
  1285	           8      switch (name[7]) {
  1286			  case 'A':
  1287	      ######        if (memEQ(name, "F_GETLEASE", 10)) {
  1288			    /*                      ^         */
  1289			#ifdef F_GETLEASE
  1290	      ######          *iv_return = F_GETLEASE;
  1291	      ######          return PERL_constant_ISIV;
  1292			#else
  1293			      return PERL_constant_NOTDEF;
  1294			#endif
  1295			    }
  1296	      ######        if (memEQ(name, "F_SETLEASE", 10)) {
  1297			    /*                      ^         */
  1298			#ifdef F_SETLEASE
  1299	      ######          *iv_return = F_SETLEASE;
  1300	      ######          return PERL_constant_ISIV;
  1301			#else
  1302			      return PERL_constant_NOTDEF;
  1303			#endif
  1304			    }
  1305	      ######        break;
  1306			  case 'I':
  1307	      ######        if (memEQ(name, "FLARGEFILE", 10)) {
  1308			    /*                      ^         */
  1309			#ifdef FLARGEFILE
  1310			      *iv_return = FLARGEFILE;
  1311			      return PERL_constant_ISIV;
  1312			#else
  1313	      ######          return PERL_constant_NOTDEF;
  1314			#endif
  1315			    }
  1316	      ######        if (memEQ(name, "LOCK_WRITE", 10)) {
  1317			    /*                      ^         */
  1318			#ifdef LOCK_WRITE
  1319	      ######          *iv_return = LOCK_WRITE;
  1320	      ######          return PERL_constant_ISIV;
  1321			#else
  1322			      return PERL_constant_NOTDEF;
  1323			#endif
  1324			    }
  1325	           6        break;
  1326			  case 'L':
  1327	           6        if (memEQ(name, "O_NOFOLLOW", 10)) {
  1328			    /*                      ^         */
  1329			#ifdef O_NOFOLLOW
  1330	           6          *iv_return = O_NOFOLLOW;
  1331	           6          return PERL_constant_ISIV;
  1332			#else
  1333			      return PERL_constant_NOTDEF;
  1334			#endif
  1335			    }
  1336	           2        break;
  1337			  case 'O':
  1338	           2        if (memEQ(name, "O_NONBLOCK", 10)) {
  1339			    /*                      ^         */
  1340			#ifdef O_NONBLOCK
  1341	           2          *iv_return = O_NONBLOCK;
  1342	           2          return PERL_constant_ISIV;
  1343			#else
  1344			      return PERL_constant_NOTDEF;
  1345			#endif
  1346			    }
  1347	      ######        break;
  1348			  case 'P':
  1349	      ######        if (memEQ(name, "F_FREESP64", 10)) {
  1350			    /*                      ^         */
  1351			#ifdef F_FREESP64
  1352			      *iv_return = F_FREESP64;
  1353			      return PERL_constant_ISIV;
  1354			#else
  1355	      ######          return PERL_constant_NOTDEF;
  1356			#endif
  1357			    }
  1358	      ######        break;
  1359			  case 'W':
  1360	      ######        if (memEQ(name, "F_SETLKW64", 10)) {
  1361			    /*                      ^         */
  1362			#ifdef F_SETLKW64
  1363	      ######          *iv_return = F_SETLKW64;
  1364	      ######          return PERL_constant_ISIV;
  1365			#else
  1366			      return PERL_constant_NOTDEF;
  1367			#endif
  1368			    }
  1369	      ######        break;
  1370			  case 'X':
  1371	      ######        if (memEQ(name, "FD_CLOEXEC", 10)) {
  1372			    /*                      ^         */
  1373			#ifdef FD_CLOEXEC
  1374	      ######          *iv_return = FD_CLOEXEC;
  1375	      ######          return PERL_constant_ISIV;
  1376			#else
  1377			      return PERL_constant_NOTDEF;
  1378			#endif
  1379			    }
  1380	      ######        break;
  1381			  }
  1382	      ######      return PERL_constant_NOTFOUND;
  1383			}
  1384			
  1385			static int
  1386	          18    constant_11 (pTHX_ const char *name, IV *iv_return) {
  1387			  /* When generated this function returned values for the list of names given
  1388			     here.  However, subsequent manual editing may have added or removed some.
  1389			     F_ALLOCSP64 O_DIRECTORY O_LARGEFILE O_NOINHERIT O_TEMPORARY */
  1390			  /* Offset 5 gives the best switch position.  */
  1391	          18      switch (name[5]) {
  1392			  case 'E':
  1393	      ######        if (memEQ(name, "O_DIRECTORY", 11)) {
  1394			    /*                    ^            */
  1395			#ifdef O_DIRECTORY
  1396	      ######          *iv_return = O_DIRECTORY;
  1397	      ######          return PERL_constant_ISIV;
  1398			#else
  1399			      return PERL_constant_NOTDEF;
  1400			#endif
  1401			    }
  1402	           6        break;
  1403			  case 'G':
  1404	           6        if (memEQ(name, "O_LARGEFILE", 11)) {
  1405			    /*                    ^            */
  1406			#ifdef O_LARGEFILE
  1407	           6          *iv_return = O_LARGEFILE;
  1408	           6          return PERL_constant_ISIV;
  1409			#else
  1410			      return PERL_constant_NOTDEF;
  1411			#endif
  1412			    }
  1413	           6        break;
  1414			  case 'N':
  1415	           6        if (memEQ(name, "O_NOINHERIT", 11)) {
  1416			    /*                    ^            */
  1417			#ifdef O_NOINHERIT
  1418			      *iv_return = O_NOINHERIT;
  1419			      return PERL_constant_ISIV;
  1420			#else
  1421	           6          return PERL_constant_NOTDEF;
  1422			#endif
  1423			    }
  1424	      ######        break;
  1425			  case 'O':
  1426	      ######        if (memEQ(name, "F_ALLOCSP64", 11)) {
  1427			    /*                    ^            */
  1428			#ifdef F_ALLOCSP64
  1429			      *iv_return = F_ALLOCSP64;
  1430			      return PERL_constant_ISIV;
  1431			#else
  1432	      ######          return PERL_constant_NOTDEF;
  1433			#endif
  1434			    }
  1435	           6        break;
  1436			  case 'P':
  1437	           6        if (memEQ(name, "O_TEMPORARY", 11)) {
  1438			    /*                    ^            */
  1439			#ifdef O_TEMPORARY
  1440			      *iv_return = O_TEMPORARY;
  1441			      return PERL_constant_ISIV;
  1442			#else
  1443	           6          return PERL_constant_NOTDEF;
  1444			#endif
  1445			    }
  1446	      ######        break;
  1447			  }
  1448	      ######      return PERL_constant_NOTFOUND;
  1449			}
  1450			
  1451			static int
  1452	         262    constant (pTHX_ const char *name, STRLEN len, IV *iv_return) {
  1453			  /* Initially switch on the length of the name.  */
  1454			  /* When generated this function returned values for the list of names given
  1455			     in this section of perl code.  Rather than manually editing these functions
  1456			     to add or remove constants, which would result in this comment and section
  1457			     of code becoming inaccurate, we recommend that you edit this section of
  1458			     code, and use it to regenerate a new set of constant functions which you
  1459			     then use to replace the originals.
  1460			
  1461			     Regenerate these constant functions by feeding this entire source file to
  1462			     perl -x
  1463			
  1464			#!/home/nick/Perl/25060-g-gcov/miniperl -w
  1465			use ExtUtils::Constant qw (constant_types C_constant XS_constant);
  1466			
  1467			my $types = {map {($_, 1)} qw(IV)};
  1468			my @names = (qw(DN_ACCESS DN_ATTRIB DN_CREATE DN_DELETE DN_MODIFY DN_MULTISHOT
  1469				       DN_RENAME FAPPEND FASYNC FCREAT FDEFER FDSYNC FD_CLOEXEC FEXCL
  1470				       FLARGEFILE FNDELAY FNONBLOCK FRSYNC FSYNC FTRUNC F_ALLOCSP
  1471				       F_ALLOCSP64 F_COMPAT F_DUP2FD F_DUPFD F_EXLCK F_FREESP
  1472				       F_FREESP64 F_FSYNC F_FSYNC64 F_GETFD F_GETFL F_GETLEASE F_GETLK
  1473				       F_GETLK64 F_GETOWN F_GETSIG F_NODNY F_NOTIFY F_POSIX F_RDACC
  1474				       F_RDDNY F_RDLCK F_RWACC F_RWDNY F_SETFD F_SETFL F_SETLEASE
  1475				       F_SETLK F_SETLK64 F_SETLKW F_SETLKW64 F_SETOWN F_SETSIG F_SHARE
  1476				       F_SHLCK F_UNLCK F_UNSHARE F_WRACC F_WRDNY F_WRLCK LOCK_MAND
  1477				       LOCK_READ LOCK_RW LOCK_WRITE O_ACCMODE O_ALIAS O_APPEND O_ASYNC
  1478				       O_BINARY O_CREAT O_DEFER O_DIRECT O_DIRECTORY O_DSYNC O_EXCL
  1479				       O_EXLOCK O_IGNORE_CTTY O_LARGEFILE O_NDELAY O_NOATIME O_NOCTTY
  1480				       O_NOFOLLOW O_NOINHERIT O_NOLINK O_NONBLOCK O_NOTRANS O_RANDOM
  1481				       O_RAW O_RDONLY O_RDWR O_RSRC O_RSYNC O_SEQUENTIAL O_SHLOCK
  1482				       O_SYNC O_TEMPORARY O_TEXT O_TRUNC O_WRONLY S_ENFMT S_IEXEC
  1483				       S_IFBLK S_IFCHR S_IFDIR S_IFIFO S_IFLNK S_IFREG S_IFSOCK S_IFWHT
  1484				       S_IREAD S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU S_ISGID
  1485				       S_ISTXT S_ISUID S_ISVTX S_IWGRP S_IWOTH S_IWRITE S_IWUSR S_IXGRP
  1486				       S_IXOTH S_IXUSR),
  1487			            {name=>"LOCK_EX", type=>"IV", default=>["IV", "2"]},
  1488			            {name=>"LOCK_NB", type=>"IV", default=>["IV", "4"]},
  1489			            {name=>"LOCK_SH", type=>"IV", default=>["IV", "1"]},
  1490			            {name=>"LOCK_UN", type=>"IV", default=>["IV", "8"]},
  1491			            {name=>"SEEK_CUR", type=>"IV", default=>["IV", "1"]},
  1492			            {name=>"SEEK_END", type=>"IV", default=>["IV", "2"]},
  1493			            {name=>"SEEK_SET", type=>"IV", default=>["IV", "0"]},
  1494			            {name=>"_S_IFMT", type=>"IV", macro=>"S_IFMT", value=>"S_IFMT"});
  1495			
  1496			print constant_types(); # macro defs
  1497			foreach (C_constant ("Fcntl", 'constant', 'IV', $types, undef, 3, @names) ) {
  1498			    print $_, "\n"; # C constant subs
  1499			}
  1500			print "#### XS Section:\n";
  1501			print XS_constant ("Fcntl", $types);
  1502			__END__
  1503			   */
  1504			
  1505	         262      switch (len) {
  1506			  case 5:
  1507	      ######        return constant_5 (aTHX_ name, iv_return);
  1508	          59        break;
  1509			  case 6:
  1510	          59        return constant_6 (aTHX_ name, iv_return);
  1511	          79        break;
  1512			  case 7:
  1513	          79        return constant_7 (aTHX_ name, iv_return);
  1514	          98        break;
  1515			  case 8:
  1516	          98        return constant_8 (aTHX_ name, iv_return);
  1517	      ######        break;
  1518			  case 9:
  1519	      ######        return constant_9 (aTHX_ name, iv_return);
  1520	           8        break;
  1521			  case 10:
  1522	           8        return constant_10 (aTHX_ name, iv_return);
  1523	          18        break;
  1524			  case 11:
  1525	          18        return constant_11 (aTHX_ name, iv_return);
  1526	      ######        break;
  1527			  case 12:
  1528			    /* Names all of length 12.  */
  1529			    /* DN_MULTISHOT O_SEQUENTIAL */
  1530			    /* Offset 8 gives the best switch position.  */
  1531	      ######        switch (name[8]) {
  1532			    case 'S':
  1533	      ######          if (memEQ(name, "DN_MULTISHOT", 12)) {
  1534			      /*                       ^          */
  1535			#ifdef DN_MULTISHOT
  1536	      ######            *iv_return = DN_MULTISHOT;
  1537	      ######            return PERL_constant_ISIV;
  1538			#else
  1539			        return PERL_constant_NOTDEF;
  1540			#endif
  1541			      }
  1542	      ######          break;
  1543			    case 'T':
  1544	      ######          if (memEQ(name, "O_SEQUENTIAL", 12)) {
  1545			      /*                       ^          */
  1546			#ifdef O_SEQUENTIAL
  1547			        *iv_return = O_SEQUENTIAL;
  1548			        return PERL_constant_ISIV;
  1549			#else
  1550	      ######            return PERL_constant_NOTDEF;
  1551			#endif
  1552			      }
  1553	      ######          break;
  1554			    }
  1555	      ######        break;
  1556			  case 13:
  1557	      ######        if (memEQ(name, "O_IGNORE_CTTY", 13)) {
  1558			#ifdef O_IGNORE_CTTY
  1559			      *iv_return = O_IGNORE_CTTY;
  1560			      return PERL_constant_ISIV;
  1561			#else
  1562	      ######          return PERL_constant_NOTDEF;
  1563			#endif
  1564			    }
  1565	      ######        break;
  1566			  }
  1567	      ######      return PERL_constant_NOTFOUND;
  1568			}
  1569