#include "mod_perl.h"


/*
 * *********** WARNING **************
 * This file generated by ModPerl::Code/0.01
 * Any changes made here will be lost
 * ***********************************
 * 01: lib/ModPerl/Code.pm:732
 * 02: lib/ModPerl/Code.pm:758
 * 03: Makefile.PL:383
 * 04: Makefile.PL:96
 */

#include "modperl_const.h"

SV *modperl_constants_lookup_apache2_const(pTHX_ const char *name)
{
    if (*name == 'A' && strnEQ(name, "Apache2::Const::", 16)) {
        name += 16;
    }

    switch (*name) {
      case 'A':

          if (strEQ(name, "AUTH_REQUIRED")) {
              return newSViv(HTTP_UNAUTHORIZED);
          }


          if (strEQ(name, "ACCESS_CONF")) {
              return newSViv(ACCESS_CONF);
          }

      break;
      case 'C':

          if (strEQ(name, "CR")) {
              return newSViv(CR);
          }


          if (strEQ(name, "CRLF")) {
              return newSVpv(CRLF, 0);
          }


          if (strEQ(name, "CONN_UNKNOWN")) {
              return newSViv(AP_CONN_UNKNOWN);
          }


          if (strEQ(name, "CONN_CLOSE")) {
              return newSViv(AP_CONN_CLOSE);
          }


          if (strEQ(name, "CONN_KEEPALIVE")) {
              return newSViv(AP_CONN_KEEPALIVE);
          }

      break;
      case 'D':

          if (strEQ(name, "DIR_MAGIC_TYPE")) {
              return newSVpv(DIR_MAGIC_TYPE, 0);
          }


          if (strEQ(name, "DECLINED")) {
              return newSViv(DECLINED);
          }


          if (strEQ(name, "DONE")) {
              return newSViv(DONE);
          }


          if (strEQ(name, "DECLINE_CMD")) {
              return newSVpv(DECLINE_CMD, 0);
          }

      break;
      case 'E':

          if (strEQ(name, "EXEC_ON_READ")) {
              return newSViv(EXEC_ON_READ);
          }

      break;
      case 'F':

          if (strEQ(name, "FTYPE_RESOURCE")) {
              return newSViv(AP_FTYPE_RESOURCE);
          }


          if (strEQ(name, "FTYPE_CONTENT_SET")) {
              return newSViv(AP_FTYPE_CONTENT_SET);
          }


          if (strEQ(name, "FTYPE_PROTOCOL")) {
              return newSViv(AP_FTYPE_PROTOCOL);
          }


          if (strEQ(name, "FTYPE_TRANSCODE")) {
              return newSViv(AP_FTYPE_TRANSCODE);
          }


          if (strEQ(name, "FTYPE_CONNECTION")) {
              return newSViv(AP_FTYPE_CONNECTION);
          }


          if (strEQ(name, "FTYPE_NETWORK")) {
              return newSViv(AP_FTYPE_NETWORK);
          }


          if (strEQ(name, "FORBIDDEN")) {
              return newSViv(HTTP_FORBIDDEN);
          }


          if (strEQ(name, "FLAG")) {
              return newSViv(FLAG);
          }

      break;
      case 'G':

          if (strEQ(name, "GLOBAL_ONLY")) {
              return newSViv(GLOBAL_ONLY);
          }

      break;
      case 'H':

          if (strEQ(name, "HTTP_CONTINUE")) {
              return newSViv(HTTP_CONTINUE);
          }


          if (strEQ(name, "HTTP_SWITCHING_PROTOCOLS")) {
              return newSViv(HTTP_SWITCHING_PROTOCOLS);
          }


          if (strEQ(name, "HTTP_PROCESSING")) {
              return newSViv(HTTP_PROCESSING);
          }


          if (strEQ(name, "HTTP_OK")) {
              return newSViv(HTTP_OK);
          }


          if (strEQ(name, "HTTP_CREATED")) {
              return newSViv(HTTP_CREATED);
          }


          if (strEQ(name, "HTTP_ACCEPTED")) {
              return newSViv(HTTP_ACCEPTED);
          }


          if (strEQ(name, "HTTP_NON_AUTHORITATIVE")) {
              return newSViv(HTTP_NON_AUTHORITATIVE);
          }


          if (strEQ(name, "HTTP_NO_CONTENT")) {
              return newSViv(HTTP_NO_CONTENT);
          }


          if (strEQ(name, "HTTP_RESET_CONTENT")) {
              return newSViv(HTTP_RESET_CONTENT);
          }


          if (strEQ(name, "HTTP_PARTIAL_CONTENT")) {
              return newSViv(HTTP_PARTIAL_CONTENT);
          }


          if (strEQ(name, "HTTP_MULTI_STATUS")) {
              return newSViv(HTTP_MULTI_STATUS);
          }


          if (strEQ(name, "HTTP_MULTIPLE_CHOICES")) {
              return newSViv(HTTP_MULTIPLE_CHOICES);
          }


          if (strEQ(name, "HTTP_MOVED_PERMANENTLY")) {
              return newSViv(HTTP_MOVED_PERMANENTLY);
          }


          if (strEQ(name, "HTTP_MOVED_TEMPORARILY")) {
              return newSViv(HTTP_MOVED_TEMPORARILY);
          }


          if (strEQ(name, "HTTP_SEE_OTHER")) {
              return newSViv(HTTP_SEE_OTHER);
          }


          if (strEQ(name, "HTTP_NOT_MODIFIED")) {
              return newSViv(HTTP_NOT_MODIFIED);
          }


          if (strEQ(name, "HTTP_USE_PROXY")) {
              return newSViv(HTTP_USE_PROXY);
          }


          if (strEQ(name, "HTTP_TEMPORARY_REDIRECT")) {
              return newSViv(HTTP_TEMPORARY_REDIRECT);
          }


          if (strEQ(name, "HTTP_BAD_REQUEST")) {
              return newSViv(HTTP_BAD_REQUEST);
          }


          if (strEQ(name, "HTTP_UNAUTHORIZED")) {
              return newSViv(HTTP_UNAUTHORIZED);
          }


          if (strEQ(name, "HTTP_PAYMENT_REQUIRED")) {
              return newSViv(HTTP_PAYMENT_REQUIRED);
          }


          if (strEQ(name, "HTTP_FORBIDDEN")) {
              return newSViv(HTTP_FORBIDDEN);
          }


          if (strEQ(name, "HTTP_NOT_FOUND")) {
              return newSViv(HTTP_NOT_FOUND);
          }


          if (strEQ(name, "HTTP_METHOD_NOT_ALLOWED")) {
              return newSViv(HTTP_METHOD_NOT_ALLOWED);
          }


          if (strEQ(name, "HTTP_NOT_ACCEPTABLE")) {
              return newSViv(HTTP_NOT_ACCEPTABLE);
          }


          if (strEQ(name, "HTTP_PROXY_AUTHENTICATION_REQUIRED")) {
              return newSViv(HTTP_PROXY_AUTHENTICATION_REQUIRED);
          }


          if (strEQ(name, "HTTP_REQUEST_TIME_OUT")) {
              return newSViv(HTTP_REQUEST_TIME_OUT);
          }


          if (strEQ(name, "HTTP_CONFLICT")) {
              return newSViv(HTTP_CONFLICT);
          }


          if (strEQ(name, "HTTP_GONE")) {
              return newSViv(HTTP_GONE);
          }


          if (strEQ(name, "HTTP_LENGTH_REQUIRED")) {
              return newSViv(HTTP_LENGTH_REQUIRED);
          }


          if (strEQ(name, "HTTP_PRECONDITION_FAILED")) {
              return newSViv(HTTP_PRECONDITION_FAILED);
          }


          if (strEQ(name, "HTTP_REQUEST_ENTITY_TOO_LARGE")) {
              return newSViv(HTTP_REQUEST_ENTITY_TOO_LARGE);
          }


          if (strEQ(name, "HTTP_REQUEST_URI_TOO_LARGE")) {
              return newSViv(HTTP_REQUEST_URI_TOO_LARGE);
          }


          if (strEQ(name, "HTTP_UNSUPPORTED_MEDIA_TYPE")) {
              return newSViv(HTTP_UNSUPPORTED_MEDIA_TYPE);
          }


          if (strEQ(name, "HTTP_RANGE_NOT_SATISFIABLE")) {
              return newSViv(HTTP_RANGE_NOT_SATISFIABLE);
          }


          if (strEQ(name, "HTTP_EXPECTATION_FAILED")) {
              return newSViv(HTTP_EXPECTATION_FAILED);
          }


          if (strEQ(name, "HTTP_UNPROCESSABLE_ENTITY")) {
              return newSViv(HTTP_UNPROCESSABLE_ENTITY);
          }


          if (strEQ(name, "HTTP_LOCKED")) {
              return newSViv(HTTP_LOCKED);
          }


          if (strEQ(name, "HTTP_FAILED_DEPENDENCY")) {
              return newSViv(HTTP_FAILED_DEPENDENCY);
          }


          if (strEQ(name, "HTTP_UPGRADE_REQUIRED")) {
              return newSViv(HTTP_UPGRADE_REQUIRED);
          }


          if (strEQ(name, "HTTP_INTERNAL_SERVER_ERROR")) {
              return newSViv(HTTP_INTERNAL_SERVER_ERROR);
          }


          if (strEQ(name, "HTTP_NOT_IMPLEMENTED")) {
              return newSViv(HTTP_NOT_IMPLEMENTED);
          }


          if (strEQ(name, "HTTP_BAD_GATEWAY")) {
              return newSViv(HTTP_BAD_GATEWAY);
          }


          if (strEQ(name, "HTTP_SERVICE_UNAVAILABLE")) {
              return newSViv(HTTP_SERVICE_UNAVAILABLE);
          }


          if (strEQ(name, "HTTP_GATEWAY_TIME_OUT")) {
              return newSViv(HTTP_GATEWAY_TIME_OUT);
          }


          if (strEQ(name, "HTTP_VARIANT_ALSO_VARIES")) {
              return newSViv(HTTP_VARIANT_ALSO_VARIES);
          }


          if (strEQ(name, "HTTP_INSUFFICIENT_STORAGE")) {
              return newSViv(HTTP_INSUFFICIENT_STORAGE);
          }


          if (strEQ(name, "HTTP_NOT_EXTENDED")) {
              return newSViv(HTTP_NOT_EXTENDED);
          }

      break;
      case 'I':

          if (strEQ(name, "ITERATE")) {
              return newSViv(ITERATE);
          }


          if (strEQ(name, "ITERATE2")) {
              return newSViv(ITERATE2);
          }

      break;
      case 'L':

          if (strEQ(name, "LOG_EMERG")) {
              return newSViv(APLOG_EMERG);
          }


          if (strEQ(name, "LOG_ALERT")) {
              return newSViv(APLOG_ALERT);
          }


          if (strEQ(name, "LOG_CRIT")) {
              return newSViv(APLOG_CRIT);
          }


          if (strEQ(name, "LOG_ERR")) {
              return newSViv(APLOG_ERR);
          }


          if (strEQ(name, "LOG_WARNING")) {
              return newSViv(APLOG_WARNING);
          }


          if (strEQ(name, "LOG_NOTICE")) {
              return newSViv(APLOG_NOTICE);
          }


          if (strEQ(name, "LOG_INFO")) {
              return newSViv(APLOG_INFO);
          }


          if (strEQ(name, "LOG_DEBUG")) {
              return newSViv(APLOG_DEBUG);
          }


          if (strEQ(name, "LOG_LEVELMASK")) {
              return newSViv(APLOG_LEVELMASK);
          }

#ifdef APLOG_TOCLIENT

          if (strEQ(name, "LOG_TOCLIENT")) {
              return newSViv(APLOG_TOCLIENT);
          }
#endif /* APLOG_TOCLIENT */


          if (strEQ(name, "LOG_STARTUP")) {
              return newSViv(APLOG_STARTUP);
          }


          if (strEQ(name, "LF")) {
              return newSViv(LF);
          }

      break;
      case 'M':

          if (strEQ(name, "M_GET")) {
              return newSViv(M_GET);
          }


          if (strEQ(name, "M_PUT")) {
              return newSViv(M_PUT);
          }


          if (strEQ(name, "M_POST")) {
              return newSViv(M_POST);
          }


          if (strEQ(name, "M_DELETE")) {
              return newSViv(M_DELETE);
          }


          if (strEQ(name, "M_CONNECT")) {
              return newSViv(M_CONNECT);
          }


          if (strEQ(name, "M_OPTIONS")) {
              return newSViv(M_OPTIONS);
          }


          if (strEQ(name, "M_TRACE")) {
              return newSViv(M_TRACE);
          }


          if (strEQ(name, "M_PATCH")) {
              return newSViv(M_PATCH);
          }


          if (strEQ(name, "M_PROPFIND")) {
              return newSViv(M_PROPFIND);
          }


          if (strEQ(name, "M_PROPPATCH")) {
              return newSViv(M_PROPPATCH);
          }


          if (strEQ(name, "M_MKCOL")) {
              return newSViv(M_MKCOL);
          }


          if (strEQ(name, "M_COPY")) {
              return newSViv(M_COPY);
          }


          if (strEQ(name, "M_MOVE")) {
              return newSViv(M_MOVE);
          }


          if (strEQ(name, "M_LOCK")) {
              return newSViv(M_LOCK);
          }


          if (strEQ(name, "M_UNLOCK")) {
              return newSViv(M_UNLOCK);
          }


          if (strEQ(name, "M_VERSION_CONTROL")) {
              return newSViv(M_VERSION_CONTROL);
          }


          if (strEQ(name, "M_CHECKOUT")) {
              return newSViv(M_CHECKOUT);
          }


          if (strEQ(name, "M_UNCHECKOUT")) {
              return newSViv(M_UNCHECKOUT);
          }


          if (strEQ(name, "M_CHECKIN")) {
              return newSViv(M_CHECKIN);
          }


          if (strEQ(name, "M_UPDATE")) {
              return newSViv(M_UPDATE);
          }


          if (strEQ(name, "M_LABEL")) {
              return newSViv(M_LABEL);
          }


          if (strEQ(name, "M_REPORT")) {
              return newSViv(M_REPORT);
          }


          if (strEQ(name, "M_MKWORKSPACE")) {
              return newSViv(M_MKWORKSPACE);
          }


          if (strEQ(name, "M_MKACTIVITY")) {
              return newSViv(M_MKACTIVITY);
          }


          if (strEQ(name, "M_BASELINE_CONTROL")) {
              return newSViv(M_BASELINE_CONTROL);
          }


          if (strEQ(name, "M_MERGE")) {
              return newSViv(M_MERGE);
          }


          if (strEQ(name, "M_INVALID")) {
              return newSViv(M_INVALID);
          }


          if (strEQ(name, "METHODS")) {
              return newSViv(METHODS);
          }


          if (strEQ(name, "MPMQ_NOT_SUPPORTED")) {
              return newSViv(AP_MPMQ_NOT_SUPPORTED);
          }


          if (strEQ(name, "MPMQ_STATIC")) {
              return newSViv(AP_MPMQ_STATIC);
          }


          if (strEQ(name, "MPMQ_DYNAMIC")) {
              return newSViv(AP_MPMQ_DYNAMIC);
          }

#ifdef AP_MPMQ_STARTING

          if (strEQ(name, "MPMQ_STARTING")) {
              return newSViv(AP_MPMQ_STARTING);
          }
#endif /* AP_MPMQ_STARTING */

#ifdef AP_MPMQ_RUNNING

          if (strEQ(name, "MPMQ_RUNNING")) {
              return newSViv(AP_MPMQ_RUNNING);
          }
#endif /* AP_MPMQ_RUNNING */

#ifdef AP_MPMQ_STOPPING

          if (strEQ(name, "MPMQ_STOPPING")) {
              return newSViv(AP_MPMQ_STOPPING);
          }
#endif /* AP_MPMQ_STOPPING */


          if (strEQ(name, "MPMQ_MAX_DAEMON_USED")) {
              return newSViv(AP_MPMQ_MAX_DAEMON_USED);
          }


          if (strEQ(name, "MPMQ_IS_THREADED")) {
              return newSViv(AP_MPMQ_IS_THREADED);
          }


          if (strEQ(name, "MPMQ_IS_FORKED")) {
              return newSViv(AP_MPMQ_IS_FORKED);
          }


          if (strEQ(name, "MPMQ_HARD_LIMIT_DAEMONS")) {
              return newSViv(AP_MPMQ_HARD_LIMIT_DAEMONS);
          }


          if (strEQ(name, "MPMQ_HARD_LIMIT_THREADS")) {
              return newSViv(AP_MPMQ_HARD_LIMIT_THREADS);
          }


          if (strEQ(name, "MPMQ_MAX_THREADS")) {
              return newSViv(AP_MPMQ_MAX_THREADS);
          }


          if (strEQ(name, "MPMQ_MIN_SPARE_DAEMONS")) {
              return newSViv(AP_MPMQ_MIN_SPARE_DAEMONS);
          }


          if (strEQ(name, "MPMQ_MIN_SPARE_THREADS")) {
              return newSViv(AP_MPMQ_MIN_SPARE_THREADS);
          }


          if (strEQ(name, "MPMQ_MAX_SPARE_DAEMONS")) {
              return newSViv(AP_MPMQ_MAX_SPARE_DAEMONS);
          }


          if (strEQ(name, "MPMQ_MAX_SPARE_THREADS")) {
              return newSViv(AP_MPMQ_MAX_SPARE_THREADS);
          }


          if (strEQ(name, "MPMQ_MAX_REQUESTS_DAEMON")) {
              return newSViv(AP_MPMQ_MAX_REQUESTS_DAEMON);
          }


          if (strEQ(name, "MPMQ_MAX_DAEMONS")) {
              return newSViv(AP_MPMQ_MAX_DAEMONS);
          }

#ifdef AP_MPMQ_MPM_STATE

          if (strEQ(name, "MPMQ_MPM_STATE")) {
              return newSViv(AP_MPMQ_MPM_STATE);
          }
#endif /* AP_MPMQ_MPM_STATE */


          if (strEQ(name, "MODE_READBYTES")) {
              return newSViv(AP_MODE_READBYTES);
          }


          if (strEQ(name, "MODE_GETLINE")) {
              return newSViv(AP_MODE_GETLINE);
          }


          if (strEQ(name, "MODE_EATCRLF")) {
              return newSViv(AP_MODE_EATCRLF);
          }


          if (strEQ(name, "MODE_SPECULATIVE")) {
              return newSViv(AP_MODE_SPECULATIVE);
          }


          if (strEQ(name, "MODE_EXHAUSTIVE")) {
              return newSViv(AP_MODE_EXHAUSTIVE);
          }


          if (strEQ(name, "MODE_INIT")) {
              return newSViv(AP_MODE_INIT);
          }

      break;
      case 'N':

          if (strEQ(name, "NOT_IN_VIRTUALHOST")) {
              return newSViv(NOT_IN_VIRTUALHOST);
          }


          if (strEQ(name, "NOT_IN_LIMIT")) {
              return newSViv(NOT_IN_LIMIT);
          }


          if (strEQ(name, "NOT_IN_DIRECTORY")) {
              return newSViv(NOT_IN_DIRECTORY);
          }


          if (strEQ(name, "NOT_IN_LOCATION")) {
              return newSViv(NOT_IN_LOCATION);
          }


          if (strEQ(name, "NOT_IN_FILES")) {
              return newSViv(NOT_IN_FILES);
          }


          if (strEQ(name, "NOT_IN_DIR_LOC_FILE")) {
              return newSViv(NOT_IN_DIR_LOC_FILE);
          }


          if (strEQ(name, "NOT_FOUND")) {
              return newSViv(HTTP_NOT_FOUND);
          }


          if (strEQ(name, "NO_ARGS")) {
              return newSViv(NO_ARGS);
          }

      break;
      case 'O':

          if (strEQ(name, "OPT_NONE")) {
              return newSViv(OPT_NONE);
          }


          if (strEQ(name, "OPT_INDEXES")) {
              return newSViv(OPT_INDEXES);
          }


          if (strEQ(name, "OPT_INCLUDES")) {
              return newSViv(OPT_INCLUDES);
          }


          if (strEQ(name, "OPT_SYM_LINKS")) {
              return newSViv(OPT_SYM_LINKS);
          }


          if (strEQ(name, "OPT_EXECCGI")) {
              return newSViv(OPT_EXECCGI);
          }


          if (strEQ(name, "OPT_UNSET")) {
              return newSViv(OPT_UNSET);
          }


          if (strEQ(name, "OPT_INCNOEXEC")) {
              return newSViv(OPT_INCNOEXEC);
          }


          if (strEQ(name, "OPT_SYM_OWNER")) {
              return newSViv(OPT_SYM_OWNER);
          }


          if (strEQ(name, "OPT_MULTI")) {
              return newSViv(OPT_MULTI);
          }


          if (strEQ(name, "OPT_ALL")) {
              return newSViv(OPT_ALL);
          }


          if (strEQ(name, "OK")) {
              return newSViv(OK);
          }


          if (strEQ(name, "OR_NONE")) {
              return newSViv(OR_NONE);
          }


          if (strEQ(name, "OR_LIMIT")) {
              return newSViv(OR_LIMIT);
          }


          if (strEQ(name, "OR_OPTIONS")) {
              return newSViv(OR_OPTIONS);
          }


          if (strEQ(name, "OR_FILEINFO")) {
              return newSViv(OR_FILEINFO);
          }


          if (strEQ(name, "OR_AUTHCFG")) {
              return newSViv(OR_AUTHCFG);
          }


          if (strEQ(name, "OR_INDEXES")) {
              return newSViv(OR_INDEXES);
          }


          if (strEQ(name, "OR_UNSET")) {
              return newSViv(OR_UNSET);
          }


          if (strEQ(name, "OR_ALL")) {
              return newSViv(OR_ALL);
          }

      break;
      case 'R':

          if (strEQ(name, "REDIRECT")) {
              return newSViv(HTTP_MOVED_TEMPORARILY);
          }


          if (strEQ(name, "RAW_ARGS")) {
              return newSViv(RAW_ARGS);
          }


          if (strEQ(name, "RSRC_CONF")) {
              return newSViv(RSRC_CONF);
          }


          if (strEQ(name, "REMOTE_HOST")) {
              return newSViv(REMOTE_HOST);
          }


          if (strEQ(name, "REMOTE_NAME")) {
              return newSViv(REMOTE_NAME);
          }


          if (strEQ(name, "REMOTE_NOLOOKUP")) {
              return newSViv(REMOTE_NOLOOKUP);
          }


          if (strEQ(name, "REMOTE_DOUBLE_REV")) {
              return newSViv(REMOTE_DOUBLE_REV);
          }

      break;
      case 'S':

          if (strEQ(name, "SATISFY_ALL")) {
              return newSViv(SATISFY_ALL);
          }


          if (strEQ(name, "SATISFY_ANY")) {
              return newSViv(SATISFY_ANY);
          }


          if (strEQ(name, "SATISFY_NOSPEC")) {
              return newSViv(SATISFY_NOSPEC);
          }


          if (strEQ(name, "SERVER_ERROR")) {
              return newSViv(HTTP_INTERNAL_SERVER_ERROR);
          }

      break;
      case 'T':

          if (strEQ(name, "TAKE1")) {
              return newSViv(TAKE1);
          }


          if (strEQ(name, "TAKE2")) {
              return newSViv(TAKE2);
          }


          if (strEQ(name, "TAKE12")) {
              return newSViv(TAKE12);
          }


          if (strEQ(name, "TAKE3")) {
              return newSViv(TAKE3);
          }


          if (strEQ(name, "TAKE23")) {
              return newSViv(TAKE23);
          }


          if (strEQ(name, "TAKE123")) {
              return newSViv(TAKE123);
          }


          if (strEQ(name, "TAKE13")) {
              return newSViv(TAKE13);
          }

      break;
    };
    Perl_croak(aTHX_ "unknown Apache2::Const:: constant %s", name);
    return newSViv(MP_ENOCONST);
}

SV *modperl_constants_lookup_apr_const(pTHX_ const char *name)
{
    if (*name == 'A' && strnEQ(name, "APR::Const::", 12)) {
        name += 12;
    }

    switch (*name) {
      case 'B':

          if (strEQ(name, "BLOCK_READ")) {
              return newSViv(APR_BLOCK_READ);
          }

      break;
      case 'E':

          if (strEQ(name, "ENOSTAT")) {
              return newSViv(APR_ENOSTAT);
          }


          if (strEQ(name, "ENOPOOL")) {
              return newSViv(APR_ENOPOOL);
          }


          if (strEQ(name, "EBADDATE")) {
              return newSViv(APR_EBADDATE);
          }


          if (strEQ(name, "EINVALSOCK")) {
              return newSViv(APR_EINVALSOCK);
          }


          if (strEQ(name, "ENOPROC")) {
              return newSViv(APR_ENOPROC);
          }


          if (strEQ(name, "ENOTIME")) {
              return newSViv(APR_ENOTIME);
          }


          if (strEQ(name, "ENODIR")) {
              return newSViv(APR_ENODIR);
          }


          if (strEQ(name, "ENOLOCK")) {
              return newSViv(APR_ENOLOCK);
          }


          if (strEQ(name, "ENOPOLL")) {
              return newSViv(APR_ENOPOLL);
          }


          if (strEQ(name, "ENOSOCKET")) {
              return newSViv(APR_ENOSOCKET);
          }


          if (strEQ(name, "ENOTHREAD")) {
              return newSViv(APR_ENOTHREAD);
          }


          if (strEQ(name, "ENOTHDKEY")) {
              return newSViv(APR_ENOTHDKEY);
          }


          if (strEQ(name, "EGENERAL")) {
              return newSViv(APR_EGENERAL);
          }


          if (strEQ(name, "ENOSHMAVAIL")) {
              return newSViv(APR_ENOSHMAVAIL);
          }


          if (strEQ(name, "EBADIP")) {
              return newSViv(APR_EBADIP);
          }


          if (strEQ(name, "EBADMASK")) {
              return newSViv(APR_EBADMASK);
          }


          if (strEQ(name, "EDSOOPEN")) {
              return newSViv(APR_EDSOOPEN);
          }


          if (strEQ(name, "EABSOLUTE")) {
              return newSViv(APR_EABSOLUTE);
          }


          if (strEQ(name, "ERELATIVE")) {
              return newSViv(APR_ERELATIVE);
          }


          if (strEQ(name, "EINCOMPLETE")) {
              return newSViv(APR_EINCOMPLETE);
          }


          if (strEQ(name, "EABOVEROOT")) {
              return newSViv(APR_EABOVEROOT);
          }


          if (strEQ(name, "EBADPATH")) {
              return newSViv(APR_EBADPATH);
          }


          if (strEQ(name, "EPATHWILD")) {
              return newSViv(APR_EPATHWILD);
          }


          if (strEQ(name, "ESYMNOTFOUND")) {
              return newSViv(APR_ESYMNOTFOUND);
          }


          if (strEQ(name, "EPROC_UNKNOWN")) {
              return newSViv(APR_EPROC_UNKNOWN);
          }


          if (strEQ(name, "EOF")) {
              return newSViv(APR_EOF);
          }


          if (strEQ(name, "EINIT")) {
              return newSViv(APR_EINIT);
          }


          if (strEQ(name, "ENOTIMPL")) {
              return newSViv(APR_ENOTIMPL);
          }


          if (strEQ(name, "EMISMATCH")) {
              return newSViv(APR_EMISMATCH);
          }


          if (strEQ(name, "EBUSY")) {
              return newSViv(APR_EBUSY);
          }


          if (strEQ(name, "EACCES")) {
              return newSViv(APR_EACCES);
          }


          if (strEQ(name, "EEXIST")) {
              return newSViv(APR_EEXIST);
          }


          if (strEQ(name, "ENAMETOOLONG")) {
              return newSViv(APR_ENAMETOOLONG);
          }


          if (strEQ(name, "ENOENT")) {
              return newSViv(APR_ENOENT);
          }


          if (strEQ(name, "ENOTDIR")) {
              return newSViv(APR_ENOTDIR);
          }


          if (strEQ(name, "ENOSPC")) {
              return newSViv(APR_ENOSPC);
          }


          if (strEQ(name, "ENOMEM")) {
              return newSViv(APR_ENOMEM);
          }


          if (strEQ(name, "EMFILE")) {
              return newSViv(APR_EMFILE);
          }


          if (strEQ(name, "ENFILE")) {
              return newSViv(APR_ENFILE);
          }


          if (strEQ(name, "EBADF")) {
              return newSViv(APR_EBADF);
          }


          if (strEQ(name, "EINVAL")) {
              return newSViv(APR_EINVAL);
          }


          if (strEQ(name, "ESPIPE")) {
              return newSViv(APR_ESPIPE);
          }


          if (strEQ(name, "EAGAIN")) {
              return newSViv(APR_EAGAIN);
          }


          if (strEQ(name, "EINTR")) {
              return newSViv(APR_EINTR);
          }


          if (strEQ(name, "ENOTSOCK")) {
              return newSViv(APR_ENOTSOCK);
          }


          if (strEQ(name, "ECONNREFUSED")) {
              return newSViv(APR_ECONNREFUSED);
          }


          if (strEQ(name, "EINPROGRESS")) {
              return newSViv(APR_EINPROGRESS);
          }


          if (strEQ(name, "ECONNABORTED")) {
              return newSViv(APR_ECONNABORTED);
          }


          if (strEQ(name, "ECONNRESET")) {
              return newSViv(APR_ECONNRESET);
          }


          if (strEQ(name, "ETIMEDOUT")) {
              return newSViv(APR_ETIMEDOUT);
          }


          if (strEQ(name, "EHOSTUNREACH")) {
              return newSViv(APR_EHOSTUNREACH);
          }


          if (strEQ(name, "ENETUNREACH")) {
              return newSViv(APR_ENETUNREACH);
          }


          if (strEQ(name, "EFTYPE")) {
              return newSViv(APR_EFTYPE);
          }


          if (strEQ(name, "EPIPE")) {
              return newSViv(APR_EPIPE);
          }


          if (strEQ(name, "EXDEV")) {
              return newSViv(APR_EXDEV);
          }


          if (strEQ(name, "ENOTEMPTY")) {
              return newSViv(APR_ENOTEMPTY);
          }


          if (strEQ(name, "EXCL")) {
              return newSViv(APR_EXCL);
          }


          if (strEQ(name, "END")) {
              return newSViv(APR_END);
          }

      break;
      case 'F':

          if (strEQ(name, "FILETYPE_NOFILE")) {
              return newSViv(APR_FILETYPE_NOFILE);
          }


          if (strEQ(name, "FILETYPE_REG")) {
              return newSViv(APR_FILETYPE_REG);
          }


          if (strEQ(name, "FILETYPE_DIR")) {
              return newSViv(APR_FILETYPE_DIR);
          }


          if (strEQ(name, "FILETYPE_CHR")) {
              return newSViv(APR_FILETYPE_CHR);
          }


          if (strEQ(name, "FILETYPE_BLK")) {
              return newSViv(APR_FILETYPE_BLK);
          }


          if (strEQ(name, "FILETYPE_PIPE")) {
              return newSViv(APR_FILETYPE_PIPE);
          }


          if (strEQ(name, "FILETYPE_LNK")) {
              return newSViv(APR_FILETYPE_LNK);
          }


          if (strEQ(name, "FILETYPE_SOCK")) {
              return newSViv(APR_FILETYPE_SOCK);
          }


          if (strEQ(name, "FILETYPE_UNKFILE")) {
              return newSViv(APR_FILETYPE_UNKFILE);
          }


          if (strEQ(name, "FILEPATH_NOTABOVEROOT")) {
              return newSViv(APR_FILEPATH_NOTABOVEROOT);
          }


          if (strEQ(name, "FILEPATH_SECUREROOTTEST")) {
              return newSViv(APR_FILEPATH_SECUREROOTTEST);
          }


          if (strEQ(name, "FILEPATH_SECUREROOT")) {
              return newSViv(APR_FILEPATH_SECUREROOT);
          }


          if (strEQ(name, "FILEPATH_NOTRELATIVE")) {
              return newSViv(APR_FILEPATH_NOTRELATIVE);
          }


          if (strEQ(name, "FILEPATH_NOTABSOLUTE")) {
              return newSViv(APR_FILEPATH_NOTABSOLUTE);
          }


          if (strEQ(name, "FILEPATH_NATIVE")) {
              return newSViv(APR_FILEPATH_NATIVE);
          }


          if (strEQ(name, "FILEPATH_TRUENAME")) {
              return newSViv(APR_FILEPATH_TRUENAME);
          }


          if (strEQ(name, "FILEPATH_ENCODING_UNKNOWN")) {
              return newSViv(APR_FILEPATH_ENCODING_UNKNOWN);
          }


          if (strEQ(name, "FILEPATH_ENCODING_LOCALE")) {
              return newSViv(APR_FILEPATH_ENCODING_LOCALE);
          }


          if (strEQ(name, "FILEPATH_ENCODING_UTF8")) {
              return newSViv(APR_FILEPATH_ENCODING_UTF8);
          }


          if (strEQ(name, "FOPEN_READ")) {
              return newSViv(APR_FOPEN_READ);
          }


          if (strEQ(name, "FOPEN_WRITE")) {
              return newSViv(APR_FOPEN_WRITE);
          }


          if (strEQ(name, "FOPEN_CREATE")) {
              return newSViv(APR_FOPEN_CREATE);
          }


          if (strEQ(name, "FOPEN_APPEND")) {
              return newSViv(APR_FOPEN_APPEND);
          }


          if (strEQ(name, "FOPEN_TRUNCATE")) {
              return newSViv(APR_FOPEN_TRUNCATE);
          }


          if (strEQ(name, "FOPEN_BINARY")) {
              return newSViv(APR_FOPEN_BINARY);
          }


          if (strEQ(name, "FOPEN_EXCL")) {
              return newSViv(APR_FOPEN_EXCL);
          }


          if (strEQ(name, "FOPEN_BUFFERED")) {
              return newSViv(APR_FOPEN_BUFFERED);
          }


          if (strEQ(name, "FOPEN_DELONCLOSE")) {
              return newSViv(APR_FOPEN_DELONCLOSE);
          }


          if (strEQ(name, "FOPEN_XTHREAD")) {
              return newSViv(APR_FOPEN_XTHREAD);
          }


          if (strEQ(name, "FOPEN_SHARELOCK")) {
              return newSViv(APR_FOPEN_SHARELOCK);
          }


          if (strEQ(name, "FOPEN_NOCLEANUP")) {
              return newSViv(APR_FOPEN_NOCLEANUP);
          }


          if (strEQ(name, "FOPEN_SENDFILE_ENABLED")) {
              return newSViv(APR_FOPEN_SENDFILE_ENABLED);
          }

#ifdef APR_FOPEN_LARGEFILE

          if (strEQ(name, "FOPEN_LARGEFILE")) {
              return newSViv(APR_FOPEN_LARGEFILE);
          }
#endif /* APR_FOPEN_LARGEFILE */


          if (strEQ(name, "FINFO_LINK")) {
              return newSViv(APR_FINFO_LINK);
          }


          if (strEQ(name, "FINFO_MTIME")) {
              return newSViv(APR_FINFO_MTIME);
          }


          if (strEQ(name, "FINFO_CTIME")) {
              return newSViv(APR_FINFO_CTIME);
          }


          if (strEQ(name, "FINFO_ATIME")) {
              return newSViv(APR_FINFO_ATIME);
          }


          if (strEQ(name, "FINFO_SIZE")) {
              return newSViv(APR_FINFO_SIZE);
          }


          if (strEQ(name, "FINFO_CSIZE")) {
              return newSViv(APR_FINFO_CSIZE);
          }


          if (strEQ(name, "FINFO_DEV")) {
              return newSViv(APR_FINFO_DEV);
          }


          if (strEQ(name, "FINFO_INODE")) {
              return newSViv(APR_FINFO_INODE);
          }


          if (strEQ(name, "FINFO_NLINK")) {
              return newSViv(APR_FINFO_NLINK);
          }


          if (strEQ(name, "FINFO_TYPE")) {
              return newSViv(APR_FINFO_TYPE);
          }


          if (strEQ(name, "FINFO_USER")) {
              return newSViv(APR_FINFO_USER);
          }


          if (strEQ(name, "FINFO_GROUP")) {
              return newSViv(APR_FINFO_GROUP);
          }


          if (strEQ(name, "FINFO_UPROT")) {
              return newSViv(APR_FINFO_UPROT);
          }


          if (strEQ(name, "FINFO_GPROT")) {
              return newSViv(APR_FINFO_GPROT);
          }


          if (strEQ(name, "FINFO_WPROT")) {
              return newSViv(APR_FINFO_WPROT);
          }


          if (strEQ(name, "FINFO_ICASE")) {
              return newSViv(APR_FINFO_ICASE);
          }


          if (strEQ(name, "FINFO_NAME")) {
              return newSViv(APR_FINFO_NAME);
          }


          if (strEQ(name, "FINFO_MIN")) {
              return newSViv(APR_FINFO_MIN);
          }


          if (strEQ(name, "FINFO_IDENT")) {
              return newSViv(APR_FINFO_IDENT);
          }


          if (strEQ(name, "FINFO_OWNER")) {
              return newSViv(APR_FINFO_OWNER);
          }


          if (strEQ(name, "FINFO_PROT")) {
              return newSViv(APR_FINFO_PROT);
          }


          if (strEQ(name, "FINFO_NORM")) {
              return newSViv(APR_FINFO_NORM);
          }


          if (strEQ(name, "FINFO_DIRENT")) {
              return newSViv(APR_FINFO_DIRENT);
          }

#ifdef APR_FPROT_USETID

          if (strEQ(name, "FPROT_USETID")) {
              return newSViv(APR_FPROT_USETID);
          }
#endif /* APR_FPROT_USETID */


          if (strEQ(name, "FPROT_UREAD")) {
              return newSViv(APR_FPROT_UREAD);
          }


          if (strEQ(name, "FPROT_UWRITE")) {
              return newSViv(APR_FPROT_UWRITE);
          }


          if (strEQ(name, "FPROT_UEXECUTE")) {
              return newSViv(APR_FPROT_UEXECUTE);
          }

#ifdef APR_FPROT_GSETID

          if (strEQ(name, "FPROT_GSETID")) {
              return newSViv(APR_FPROT_GSETID);
          }
#endif /* APR_FPROT_GSETID */


          if (strEQ(name, "FPROT_GREAD")) {
              return newSViv(APR_FPROT_GREAD);
          }


          if (strEQ(name, "FPROT_GWRITE")) {
              return newSViv(APR_FPROT_GWRITE);
          }


          if (strEQ(name, "FPROT_GEXECUTE")) {
              return newSViv(APR_FPROT_GEXECUTE);
          }

#ifdef APR_FPROT_WSTICKY

          if (strEQ(name, "FPROT_WSTICKY")) {
              return newSViv(APR_FPROT_WSTICKY);
          }
#endif /* APR_FPROT_WSTICKY */


          if (strEQ(name, "FPROT_WREAD")) {
              return newSViv(APR_FPROT_WREAD);
          }


          if (strEQ(name, "FPROT_WWRITE")) {
              return newSViv(APR_FPROT_WWRITE);
          }


          if (strEQ(name, "FPROT_WEXECUTE")) {
              return newSViv(APR_FPROT_WEXECUTE);
          }


          if (strEQ(name, "FPROT_OS_DEFAULT")) {
              return newSViv(APR_FPROT_OS_DEFAULT);
          }


          if (strEQ(name, "FLOCK_SHARED")) {
              return newSViv(APR_FLOCK_SHARED);
          }


          if (strEQ(name, "FLOCK_EXCLUSIVE")) {
              return newSViv(APR_FLOCK_EXCLUSIVE);
          }


          if (strEQ(name, "FLOCK_TYPEMASK")) {
              return newSViv(APR_FLOCK_TYPEMASK);
          }


          if (strEQ(name, "FLOCK_NONBLOCK")) {
              return newSViv(APR_FLOCK_NONBLOCK);
          }

      break;
      case 'H':

          if (strEQ(name, "HOOK_REALLY_FIRST")) {
              return newSViv(APR_HOOK_REALLY_FIRST);
          }


          if (strEQ(name, "HOOK_FIRST")) {
              return newSViv(APR_HOOK_FIRST);
          }


          if (strEQ(name, "HOOK_MIDDLE")) {
              return newSViv(APR_HOOK_MIDDLE);
          }


          if (strEQ(name, "HOOK_LAST")) {
              return newSViv(APR_HOOK_LAST);
          }


          if (strEQ(name, "HOOK_REALLY_LAST")) {
              return newSViv(APR_HOOK_REALLY_LAST);
          }

      break;
      case 'L':

          if (strEQ(name, "LOCK_FCNTL")) {
              return newSViv(APR_LOCK_FCNTL);
          }


          if (strEQ(name, "LOCK_FLOCK")) {
              return newSViv(APR_LOCK_FLOCK);
          }


          if (strEQ(name, "LOCK_SYSVSEM")) {
              return newSViv(APR_LOCK_SYSVSEM);
          }


          if (strEQ(name, "LOCK_PROC_PTHREAD")) {
              return newSViv(APR_LOCK_PROC_PTHREAD);
          }


          if (strEQ(name, "LOCK_POSIXSEM")) {
              return newSViv(APR_LOCK_POSIXSEM);
          }


          if (strEQ(name, "LOCK_DEFAULT")) {
              return newSViv(APR_LOCK_DEFAULT);
          }


          if (strEQ(name, "LIMIT_CPU")) {
              return newSViv(APR_LIMIT_CPU);
          }


          if (strEQ(name, "LIMIT_MEM")) {
              return newSViv(APR_LIMIT_MEM);
          }


          if (strEQ(name, "LIMIT_NPROC")) {
              return newSViv(APR_LIMIT_NPROC);
          }

#ifdef APR_LIMIT_NOFILE

          if (strEQ(name, "LIMIT_NOFILE")) {
              return newSViv(APR_LIMIT_NOFILE);
          }
#endif /* APR_LIMIT_NOFILE */

      break;
      case 'N':

          if (strEQ(name, "NONBLOCK_READ")) {
              return newSViv(APR_NONBLOCK_READ);
          }

      break;
      case 'O':

          if (strEQ(name, "OVERLAP_TABLES_SET")) {
              return newSViv(APR_OVERLAP_TABLES_SET);
          }


          if (strEQ(name, "OVERLAP_TABLES_MERGE")) {
              return newSViv(APR_OVERLAP_TABLES_MERGE);
          }

      break;
      case 'P':

          if (strEQ(name, "POLLIN")) {
              return newSViv(APR_POLLIN);
          }


          if (strEQ(name, "POLLPRI")) {
              return newSViv(APR_POLLPRI);
          }


          if (strEQ(name, "POLLOUT")) {
              return newSViv(APR_POLLOUT);
          }


          if (strEQ(name, "POLLERR")) {
              return newSViv(APR_POLLERR);
          }


          if (strEQ(name, "POLLHUP")) {
              return newSViv(APR_POLLHUP);
          }


          if (strEQ(name, "POLLNVAL")) {
              return newSViv(APR_POLLNVAL);
          }

      break;
      case 'S':

          if (strEQ(name, "SHUTDOWN_READ")) {
              return newSViv(APR_SHUTDOWN_READ);
          }


          if (strEQ(name, "SHUTDOWN_WRITE")) {
              return newSViv(APR_SHUTDOWN_WRITE);
          }


          if (strEQ(name, "SHUTDOWN_READWRITE")) {
              return newSViv(APR_SHUTDOWN_READWRITE);
          }


          if (strEQ(name, "SUCCESS")) {
              return newSViv(APR_SUCCESS);
          }


          if (strEQ(name, "SO_LINGER")) {
              return newSViv(APR_SO_LINGER);
          }


          if (strEQ(name, "SO_KEEPALIVE")) {
              return newSViv(APR_SO_KEEPALIVE);
          }


          if (strEQ(name, "SO_DEBUG")) {
              return newSViv(APR_SO_DEBUG);
          }


          if (strEQ(name, "SO_NONBLOCK")) {
              return newSViv(APR_SO_NONBLOCK);
          }


          if (strEQ(name, "SO_REUSEADDR")) {
              return newSViv(APR_SO_REUSEADDR);
          }


          if (strEQ(name, "SO_SNDBUF")) {
              return newSViv(APR_SO_SNDBUF);
          }


          if (strEQ(name, "SO_RCVBUF")) {
              return newSViv(APR_SO_RCVBUF);
          }


          if (strEQ(name, "SO_DISCONNECTED")) {
              return newSViv(APR_SO_DISCONNECTED);
          }

      break;
      case 'T':

          if (strEQ(name, "TIMEUP")) {
              return newSViv(APR_TIMEUP);
          }

      break;
      case 'U':

          if (strEQ(name, "URI_FTP_DEFAULT_PORT")) {
              return newSViv(APR_URI_FTP_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_SSH_DEFAULT_PORT")) {
              return newSViv(APR_URI_SSH_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_TELNET_DEFAULT_PORT")) {
              return newSViv(APR_URI_TELNET_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_GOPHER_DEFAULT_PORT")) {
              return newSViv(APR_URI_GOPHER_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_HTTP_DEFAULT_PORT")) {
              return newSViv(APR_URI_HTTP_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_POP_DEFAULT_PORT")) {
              return newSViv(APR_URI_POP_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_NNTP_DEFAULT_PORT")) {
              return newSViv(APR_URI_NNTP_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_IMAP_DEFAULT_PORT")) {
              return newSViv(APR_URI_IMAP_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_PROSPERO_DEFAULT_PORT")) {
              return newSViv(APR_URI_PROSPERO_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_WAIS_DEFAULT_PORT")) {
              return newSViv(APR_URI_WAIS_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_LDAP_DEFAULT_PORT")) {
              return newSViv(APR_URI_LDAP_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_HTTPS_DEFAULT_PORT")) {
              return newSViv(APR_URI_HTTPS_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_RTSP_DEFAULT_PORT")) {
              return newSViv(APR_URI_RTSP_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_SNEWS_DEFAULT_PORT")) {
              return newSViv(APR_URI_SNEWS_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_ACAP_DEFAULT_PORT")) {
              return newSViv(APR_URI_ACAP_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_NFS_DEFAULT_PORT")) {
              return newSViv(APR_URI_NFS_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_TIP_DEFAULT_PORT")) {
              return newSViv(APR_URI_TIP_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_SIP_DEFAULT_PORT")) {
              return newSViv(APR_URI_SIP_DEFAULT_PORT);
          }


          if (strEQ(name, "URI_UNP_OMITSITEPART")) {
              return newSViv(APR_URI_UNP_OMITSITEPART);
          }


          if (strEQ(name, "URI_UNP_OMITUSER")) {
              return newSViv(APR_URI_UNP_OMITUSER);
          }


          if (strEQ(name, "URI_UNP_OMITPASSWORD")) {
              return newSViv(APR_URI_UNP_OMITPASSWORD);
          }


          if (strEQ(name, "URI_UNP_OMITUSERINFO")) {
              return newSViv(APR_URI_UNP_OMITUSERINFO);
          }


          if (strEQ(name, "URI_UNP_REVEALPASSWORD")) {
              return newSViv(APR_URI_UNP_REVEALPASSWORD);
          }


          if (strEQ(name, "URI_UNP_OMITPATHINFO")) {
              return newSViv(APR_URI_UNP_OMITPATHINFO);
          }


          if (strEQ(name, "URI_UNP_OMITQUERY")) {
              return newSViv(APR_URI_UNP_OMITQUERY);
          }

      break;
    };
    Perl_croak(aTHX_ "unknown APR::Const:: constant %s", name);
    return newSViv(MP_ENOCONST);
}

SV *modperl_constants_lookup_modperl(pTHX_ const char *name)
{
    if (*name == 'M' && strnEQ(name, "ModPerl::", 9)) {
        name += 9;
    }

    switch (*name) {
      case 'E':

          if (strEQ(name, "EXIT")) {
              return newSViv(MODPERL_RC_EXIT);
          }

      break;
    };
    Perl_croak(aTHX_ "unknown ModPerl:: constant %s", name);
    return newSViv(MP_ENOCONST);
}

static const char *MP_constants_apache2_const_types [] = { 
   "DIR_MAGIC_TYPE",
   NULL,
};

static const char *MP_constants_apache2_const_options [] = { 
   "OPT_NONE",
   "OPT_INDEXES",
   "OPT_INCLUDES",
   "OPT_SYM_LINKS",
   "OPT_EXECCGI",
   "OPT_UNSET",
   "OPT_INCNOEXEC",
   "OPT_SYM_OWNER",
   "OPT_MULTI",
   "OPT_ALL",
   NULL,
};

static const char *MP_constants_apache2_const_satisfy [] = { 
   "SATISFY_ALL",
   "SATISFY_ANY",
   "SATISFY_NOSPEC",
   NULL,
};

static const char *MP_constants_apache2_const_http [] = { 
   "HTTP_CONTINUE",
   "HTTP_SWITCHING_PROTOCOLS",
   "HTTP_PROCESSING",
   "HTTP_OK",
   "HTTP_CREATED",
   "HTTP_ACCEPTED",
   "HTTP_NON_AUTHORITATIVE",
   "HTTP_NO_CONTENT",
   "HTTP_RESET_CONTENT",
   "HTTP_PARTIAL_CONTENT",
   "HTTP_MULTI_STATUS",
   "HTTP_MULTIPLE_CHOICES",
   "HTTP_MOVED_PERMANENTLY",
   "HTTP_MOVED_TEMPORARILY",
   "HTTP_SEE_OTHER",
   "HTTP_NOT_MODIFIED",
   "HTTP_USE_PROXY",
   "HTTP_TEMPORARY_REDIRECT",
   "HTTP_BAD_REQUEST",
   "HTTP_UNAUTHORIZED",
   "HTTP_PAYMENT_REQUIRED",
   "HTTP_FORBIDDEN",
   "HTTP_NOT_FOUND",
   "HTTP_METHOD_NOT_ALLOWED",
   "HTTP_NOT_ACCEPTABLE",
   "HTTP_PROXY_AUTHENTICATION_REQUIRED",
   "HTTP_REQUEST_TIME_OUT",
   "HTTP_CONFLICT",
   "HTTP_GONE",
   "HTTP_LENGTH_REQUIRED",
   "HTTP_PRECONDITION_FAILED",
   "HTTP_REQUEST_ENTITY_TOO_LARGE",
   "HTTP_REQUEST_URI_TOO_LARGE",
   "HTTP_UNSUPPORTED_MEDIA_TYPE",
   "HTTP_RANGE_NOT_SATISFIABLE",
   "HTTP_EXPECTATION_FAILED",
   "HTTP_UNPROCESSABLE_ENTITY",
   "HTTP_LOCKED",
   "HTTP_FAILED_DEPENDENCY",
   "HTTP_UPGRADE_REQUIRED",
   "HTTP_INTERNAL_SERVER_ERROR",
   "HTTP_NOT_IMPLEMENTED",
   "HTTP_BAD_GATEWAY",
   "HTTP_SERVICE_UNAVAILABLE",
   "HTTP_GATEWAY_TIME_OUT",
   "HTTP_VARIANT_ALSO_VARIES",
   "HTTP_INSUFFICIENT_STORAGE",
   "HTTP_NOT_EXTENDED",
   NULL,
};

static const char *MP_constants_apache2_const_context [] = { 
   "NOT_IN_VIRTUALHOST",
   "NOT_IN_LIMIT",
   "NOT_IN_DIRECTORY",
   "NOT_IN_LOCATION",
   "NOT_IN_FILES",
   "NOT_IN_DIR_LOC_FILE",
   "GLOBAL_ONLY",
   NULL,
};

static const char *MP_constants_apache2_const_methods [] = { 
   "M_GET",
   "M_PUT",
   "M_POST",
   "M_DELETE",
   "M_CONNECT",
   "M_OPTIONS",
   "M_TRACE",
   "M_PATCH",
   "M_PROPFIND",
   "M_PROPPATCH",
   "M_MKCOL",
   "M_COPY",
   "M_MOVE",
   "M_LOCK",
   "M_UNLOCK",
   "M_VERSION_CONTROL",
   "M_CHECKOUT",
   "M_UNCHECKOUT",
   "M_CHECKIN",
   "M_UPDATE",
   "M_LABEL",
   "M_REPORT",
   "M_MKWORKSPACE",
   "M_MKACTIVITY",
   "M_BASELINE_CONTROL",
   "M_MERGE",
   "M_INVALID",
   "METHODS",
   NULL,
};

static const char *MP_constants_apache2_const_log [] = { 
   "LOG_EMERG",
   "LOG_ALERT",
   "LOG_CRIT",
   "LOG_ERR",
   "LOG_WARNING",
   "LOG_NOTICE",
   "LOG_INFO",
   "LOG_DEBUG",
   "LOG_LEVELMASK",
#ifdef APLOG_TOCLIENT
   "LOG_TOCLIENT",
#endif /* APLOG_TOCLIENT */
   "LOG_STARTUP",
   NULL,
};

static const char *MP_constants_apache2_const_platform [] = { 
   "LF",
   "CR",
   "CRLF",
   NULL,
};

static const char *MP_constants_apache2_const_filter_type [] = { 
   "FTYPE_RESOURCE",
   "FTYPE_CONTENT_SET",
   "FTYPE_PROTOCOL",
   "FTYPE_TRANSCODE",
   "FTYPE_CONNECTION",
   "FTYPE_NETWORK",
   NULL,
};

static const char *MP_constants_apache2_const_mpmq [] = { 
   "MPMQ_NOT_SUPPORTED",
   "MPMQ_STATIC",
   "MPMQ_DYNAMIC",
#ifdef AP_MPMQ_STARTING
   "MPMQ_STARTING",
#endif /* AP_MPMQ_STARTING */
#ifdef AP_MPMQ_RUNNING
   "MPMQ_RUNNING",
#endif /* AP_MPMQ_RUNNING */
#ifdef AP_MPMQ_STOPPING
   "MPMQ_STOPPING",
#endif /* AP_MPMQ_STOPPING */
   "MPMQ_MAX_DAEMON_USED",
   "MPMQ_IS_THREADED",
   "MPMQ_IS_FORKED",
   "MPMQ_HARD_LIMIT_DAEMONS",
   "MPMQ_HARD_LIMIT_THREADS",
   "MPMQ_MAX_THREADS",
   "MPMQ_MIN_SPARE_DAEMONS",
   "MPMQ_MIN_SPARE_THREADS",
   "MPMQ_MAX_SPARE_DAEMONS",
   "MPMQ_MAX_SPARE_THREADS",
   "MPMQ_MAX_REQUESTS_DAEMON",
   "MPMQ_MAX_DAEMONS",
#ifdef AP_MPMQ_MPM_STATE
   "MPMQ_MPM_STATE",
#endif /* AP_MPMQ_MPM_STATE */
   NULL,
};

static const char *MP_constants_apache2_const_common [] = { 
   "DECLINED",
   "DONE",
   "OK",
   "NOT_FOUND",
   "FORBIDDEN",
   "AUTH_REQUIRED",
   "SERVER_ERROR",
   "REDIRECT",
   NULL,
};

static const char *MP_constants_apache2_const_cmd_how [] = { 
   "RAW_ARGS",
   "TAKE1",
   "TAKE2",
   "ITERATE",
   "ITERATE2",
   "FLAG",
   "NO_ARGS",
   "TAKE12",
   "TAKE3",
   "TAKE23",
   "TAKE123",
   "TAKE13",
   NULL,
};

static const char *MP_constants_apache2_const_conn_keepalive [] = { 
   "CONN_UNKNOWN",
   "CONN_CLOSE",
   "CONN_KEEPALIVE",
   NULL,
};

static const char *MP_constants_apache2_const_input_mode [] = { 
   "MODE_READBYTES",
   "MODE_GETLINE",
   "MODE_EATCRLF",
   "MODE_SPECULATIVE",
   "MODE_EXHAUSTIVE",
   "MODE_INIT",
   NULL,
};

static const char *MP_constants_apache2_const_override [] = { 
   "OR_NONE",
   "OR_LIMIT",
   "OR_OPTIONS",
   "OR_FILEINFO",
   "OR_AUTHCFG",
   "OR_INDEXES",
   "OR_UNSET",
   "ACCESS_CONF",
   "RSRC_CONF",
   "EXEC_ON_READ",
   "OR_ALL",
   NULL,
};

static const char *MP_constants_apache2_const_config [] = { 
   "DECLINE_CMD",
   NULL,
};

static const char *MP_constants_apache2_const_remotehost [] = { 
   "REMOTE_HOST",
   "REMOTE_NAME",
   "REMOTE_NOLOOKUP",
   "REMOTE_DOUBLE_REV",
   NULL,
};

const char **modperl_constants_group_lookup_apache2_const(const char *name)
{
   switch (*name) {
	case 'c':
	if(strEQ("context", name))
	   return MP_constants_apache2_const_context;
	if(strEQ("common", name))
	   return MP_constants_apache2_const_common;
	if(strEQ("cmd_how", name))
	   return MP_constants_apache2_const_cmd_how;
	if(strEQ("conn_keepalive", name))
	   return MP_constants_apache2_const_conn_keepalive;
	if(strEQ("config", name))
	   return MP_constants_apache2_const_config;
      break;
	case 'f':
	if(strEQ("filter_type", name))
	   return MP_constants_apache2_const_filter_type;
      break;
	case 'h':
	if(strEQ("http", name))
	   return MP_constants_apache2_const_http;
      break;
	case 'i':
	if(strEQ("input_mode", name))
	   return MP_constants_apache2_const_input_mode;
      break;
	case 'l':
	if(strEQ("log", name))
	   return MP_constants_apache2_const_log;
      break;
	case 'm':
	if(strEQ("methods", name))
	   return MP_constants_apache2_const_methods;
	if(strEQ("mpmq", name))
	   return MP_constants_apache2_const_mpmq;
      break;
	case 'o':
	if(strEQ("options", name))
	   return MP_constants_apache2_const_options;
	if(strEQ("override", name))
	   return MP_constants_apache2_const_override;
      break;
	case 'p':
	if(strEQ("platform", name))
	   return MP_constants_apache2_const_platform;
      break;
	case 'r':
	if(strEQ("remotehost", name))
	   return MP_constants_apache2_const_remotehost;
      break;
	case 's':
	if(strEQ("satisfy", name))
	   return MP_constants_apache2_const_satisfy;
      break;
	case 't':
	if(strEQ("types", name))
	   return MP_constants_apache2_const_types;
      break;
    };
    Perl_croak_nocontext("unknown apache2_const:: group `%s'", name);
    return NULL;
}

static const char *MP_constants_apr_const_filetype [] = { 
   "FILETYPE_NOFILE",
   "FILETYPE_REG",
   "FILETYPE_DIR",
   "FILETYPE_CHR",
   "FILETYPE_BLK",
   "FILETYPE_PIPE",
   "FILETYPE_LNK",
   "FILETYPE_SOCK",
   "FILETYPE_UNKFILE",
   NULL,
};

static const char *MP_constants_apr_const_read_type [] = { 
   "BLOCK_READ",
   "NONBLOCK_READ",
   NULL,
};

static const char *MP_constants_apr_const_status [] = { 
   "TIMEUP",
   NULL,
};

static const char *MP_constants_apr_const_table [] = { 
   "OVERLAP_TABLES_SET",
   "OVERLAP_TABLES_MERGE",
   NULL,
};

static const char *MP_constants_apr_const_shutdown_how [] = { 
   "SHUTDOWN_READ",
   "SHUTDOWN_WRITE",
   "SHUTDOWN_READWRITE",
   NULL,
};

static const char *MP_constants_apr_const_filepath [] = { 
   "FILEPATH_NOTABOVEROOT",
   "FILEPATH_SECUREROOTTEST",
   "FILEPATH_SECUREROOT",
   "FILEPATH_NOTRELATIVE",
   "FILEPATH_NOTABSOLUTE",
   "FILEPATH_NATIVE",
   "FILEPATH_TRUENAME",
   "FILEPATH_ENCODING_UNKNOWN",
   "FILEPATH_ENCODING_LOCALE",
   "FILEPATH_ENCODING_UTF8",
   NULL,
};

static const char *MP_constants_apr_const_lockmech [] = { 
   "LOCK_FCNTL",
   "LOCK_FLOCK",
   "LOCK_SYSVSEM",
   "LOCK_PROC_PTHREAD",
   "LOCK_POSIXSEM",
   "LOCK_DEFAULT",
   NULL,
};

static const char *MP_constants_apr_const_fopen [] = { 
   "FOPEN_READ",
   "FOPEN_WRITE",
   "FOPEN_CREATE",
   "FOPEN_APPEND",
   "FOPEN_TRUNCATE",
   "FOPEN_BINARY",
   "FOPEN_EXCL",
   "FOPEN_BUFFERED",
   "FOPEN_DELONCLOSE",
   "FOPEN_XTHREAD",
   "FOPEN_SHARELOCK",
   "FOPEN_NOCLEANUP",
   "FOPEN_SENDFILE_ENABLED",
#ifdef APR_FOPEN_LARGEFILE
   "FOPEN_LARGEFILE",
#endif /* APR_FOPEN_LARGEFILE */
   NULL,
};

static const char *MP_constants_apr_const_poll [] = { 
   "POLLIN",
   "POLLPRI",
   "POLLOUT",
   "POLLERR",
   "POLLHUP",
   "POLLNVAL",
   NULL,
};

static const char *MP_constants_apr_const_error [] = { 
   "ENOSTAT",
   "ENOPOOL",
   "EBADDATE",
   "EINVALSOCK",
   "ENOPROC",
   "ENOTIME",
   "ENODIR",
   "ENOLOCK",
   "ENOPOLL",
   "ENOSOCKET",
   "ENOTHREAD",
   "ENOTHDKEY",
   "EGENERAL",
   "ENOSHMAVAIL",
   "EBADIP",
   "EBADMASK",
   "EDSOOPEN",
   "EABSOLUTE",
   "ERELATIVE",
   "EINCOMPLETE",
   "EABOVEROOT",
   "EBADPATH",
   "EPATHWILD",
   "ESYMNOTFOUND",
   "EPROC_UNKNOWN",
   "EOF",
   "EINIT",
   "ENOTIMPL",
   "EMISMATCH",
   "EBUSY",
   "EACCES",
   "EEXIST",
   "ENAMETOOLONG",
   "ENOENT",
   "ENOTDIR",
   "ENOSPC",
   "ENOMEM",
   "EMFILE",
   "ENFILE",
   "EBADF",
   "EINVAL",
   "ESPIPE",
   "EAGAIN",
   "EINTR",
   "ENOTSOCK",
   "ECONNREFUSED",
   "EINPROGRESS",
   "ECONNABORTED",
   "ECONNRESET",
   "ETIMEDOUT",
   "EHOSTUNREACH",
   "ENETUNREACH",
   "EFTYPE",
   "EPIPE",
   "EXDEV",
   "ENOTEMPTY",
   "EXCL",
   "END",
   NULL,
};

static const char *MP_constants_apr_const_finfo [] = { 
   "FINFO_LINK",
   "FINFO_MTIME",
   "FINFO_CTIME",
   "FINFO_ATIME",
   "FINFO_SIZE",
   "FINFO_CSIZE",
   "FINFO_DEV",
   "FINFO_INODE",
   "FINFO_NLINK",
   "FINFO_TYPE",
   "FINFO_USER",
   "FINFO_GROUP",
   "FINFO_UPROT",
   "FINFO_GPROT",
   "FINFO_WPROT",
   "FINFO_ICASE",
   "FINFO_NAME",
   "FINFO_MIN",
   "FINFO_IDENT",
   "FINFO_OWNER",
   "FINFO_PROT",
   "FINFO_NORM",
   "FINFO_DIRENT",
   NULL,
};

static const char *MP_constants_apr_const_limit [] = { 
   "LIMIT_CPU",
   "LIMIT_MEM",
   "LIMIT_NPROC",
#ifdef APR_LIMIT_NOFILE
   "LIMIT_NOFILE",
#endif /* APR_LIMIT_NOFILE */
   NULL,
};

static const char *MP_constants_apr_const_fprot [] = { 
#ifdef APR_FPROT_USETID
   "FPROT_USETID",
#endif /* APR_FPROT_USETID */
   "FPROT_UREAD",
   "FPROT_UWRITE",
   "FPROT_UEXECUTE",
#ifdef APR_FPROT_GSETID
   "FPROT_GSETID",
#endif /* APR_FPROT_GSETID */
   "FPROT_GREAD",
   "FPROT_GWRITE",
   "FPROT_GEXECUTE",
#ifdef APR_FPROT_WSTICKY
   "FPROT_WSTICKY",
#endif /* APR_FPROT_WSTICKY */
   "FPROT_WREAD",
   "FPROT_WWRITE",
   "FPROT_WEXECUTE",
   "FPROT_OS_DEFAULT",
   NULL,
};

static const char *MP_constants_apr_const_common [] = { 
   "SUCCESS",
   NULL,
};

static const char *MP_constants_apr_const_uri [] = { 
   "URI_FTP_DEFAULT_PORT",
   "URI_SSH_DEFAULT_PORT",
   "URI_TELNET_DEFAULT_PORT",
   "URI_GOPHER_DEFAULT_PORT",
   "URI_HTTP_DEFAULT_PORT",
   "URI_POP_DEFAULT_PORT",
   "URI_NNTP_DEFAULT_PORT",
   "URI_IMAP_DEFAULT_PORT",
   "URI_PROSPERO_DEFAULT_PORT",
   "URI_WAIS_DEFAULT_PORT",
   "URI_LDAP_DEFAULT_PORT",
   "URI_HTTPS_DEFAULT_PORT",
   "URI_RTSP_DEFAULT_PORT",
   "URI_SNEWS_DEFAULT_PORT",
   "URI_ACAP_DEFAULT_PORT",
   "URI_NFS_DEFAULT_PORT",
   "URI_TIP_DEFAULT_PORT",
   "URI_SIP_DEFAULT_PORT",
   "URI_UNP_OMITSITEPART",
   "URI_UNP_OMITUSER",
   "URI_UNP_OMITPASSWORD",
   "URI_UNP_OMITUSERINFO",
   "URI_UNP_REVEALPASSWORD",
   "URI_UNP_OMITPATHINFO",
   "URI_UNP_OMITQUERY",
   NULL,
};

static const char *MP_constants_apr_const_socket [] = { 
   "SO_LINGER",
   "SO_KEEPALIVE",
   "SO_DEBUG",
   "SO_NONBLOCK",
   "SO_REUSEADDR",
   "SO_SNDBUF",
   "SO_RCVBUF",
   "SO_DISCONNECTED",
   NULL,
};

static const char *MP_constants_apr_const_hook [] = { 
   "HOOK_REALLY_FIRST",
   "HOOK_FIRST",
   "HOOK_MIDDLE",
   "HOOK_LAST",
   "HOOK_REALLY_LAST",
   NULL,
};

static const char *MP_constants_apr_const_flock [] = { 
   "FLOCK_SHARED",
   "FLOCK_EXCLUSIVE",
   "FLOCK_TYPEMASK",
   "FLOCK_NONBLOCK",
   NULL,
};

const char **modperl_constants_group_lookup_apr_const(const char *name)
{
   switch (*name) {
	case 'c':
	if(strEQ("common", name))
	   return MP_constants_apr_const_common;
      break;
	case 'e':
	if(strEQ("error", name))
	   return MP_constants_apr_const_error;
      break;
	case 'f':
	if(strEQ("filetype", name))
	   return MP_constants_apr_const_filetype;
	if(strEQ("filepath", name))
	   return MP_constants_apr_const_filepath;
	if(strEQ("fopen", name))
	   return MP_constants_apr_const_fopen;
	if(strEQ("finfo", name))
	   return MP_constants_apr_const_finfo;
	if(strEQ("fprot", name))
	   return MP_constants_apr_const_fprot;
	if(strEQ("flock", name))
	   return MP_constants_apr_const_flock;
      break;
	case 'h':
	if(strEQ("hook", name))
	   return MP_constants_apr_const_hook;
      break;
	case 'l':
	if(strEQ("lockmech", name))
	   return MP_constants_apr_const_lockmech;
	if(strEQ("limit", name))
	   return MP_constants_apr_const_limit;
      break;
	case 'p':
	if(strEQ("poll", name))
	   return MP_constants_apr_const_poll;
      break;
	case 'r':
	if(strEQ("read_type", name))
	   return MP_constants_apr_const_read_type;
      break;
	case 's':
	if(strEQ("status", name))
	   return MP_constants_apr_const_status;
	if(strEQ("shutdown_how", name))
	   return MP_constants_apr_const_shutdown_how;
	if(strEQ("socket", name))
	   return MP_constants_apr_const_socket;
      break;
	case 't':
	if(strEQ("table", name))
	   return MP_constants_apr_const_table;
      break;
	case 'u':
	if(strEQ("uri", name))
	   return MP_constants_apr_const_uri;
      break;
    };
    Perl_croak_nocontext("unknown apr_const:: group `%s'", name);
    return NULL;
}

static const char *MP_constants_modperl_common [] = { 
   "EXIT",
   NULL,
};

const char **modperl_constants_group_lookup_modperl(const char *name)
{
   switch (*name) {
	case 'c':
	if(strEQ("common", name))
	   return MP_constants_modperl_common;
      break;
    };
    Perl_croak_nocontext("unknown modperl:: group `%s'", name);
    return NULL;
}