httpd-docs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From c...@locus.apache.org
Subject cvs commit: httpd-docs-1.3/apidoc APIdict.pm dict-SECURITY_HOLE_PASS_AUTHORIZATION.html findapi api.list dict-top_module.html mkapidict
Date Mon, 18 Sep 2000 01:58:04 GMT
coar        00/09/17 18:58:03

  Modified:    apidoc   api.list dict-top_module.html mkapidict
  Added:       apidoc   APIdict.pm
                        dict-SECURITY_HOLE_PASS_AUTHORIZATION.html findapi
  Log:
  	Yo-ho.. Abstract out a bunch of the dictionary file manipulation
  	into a Perl module, modify mkapidict to use it, and add a tool
  	to find the API routine and cell declarations in the sources.
  
  Revision  Changes    Path
  1.28      +946 -552  httpd-docs-1.3/apidoc/api.list
  
  Index: api.list
  ===================================================================
  RCS file: /home/cvs/httpd-docs-1.3/apidoc/api.list,v
  retrieving revision 1.27
  retrieving revision 1.28
  diff -u -u -r1.27 -r1.28
  --- api.list	2000/08/25 12:08:28	1.27
  +++ api.list	2000/09/18 01:58:01	1.28
  @@ -55,7 +55,7 @@
   #;   |void $*(const char *component);\  #; Definition
   #;   |/*\n * Called during modules-init phase\n */\n$*("MyMod/1.0");\ #; Example
   #;   |SA-identity\                      #; Cross-references
  -#;   |dict-$*.html                      #; Entity documentation HTML file
  +#;   |<dict-$*.html                      #; Entity documentation HTML file
   #;
   #;
   #; Symbols related to how the server identifies itself
  @@ -86,43 +86,44 @@
           (void) ap_discard_request_body(r); \n \
       } \
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_field_noparam\
       |char *$*(pool *p, const char *intype);\
       |content_type = $*(r-&gt;pool, r-&gt;content_type);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_add_version_component\
       |void $*(const char *component);\
       |/*\n * Called during modules-init phase\n */\n$*("MyMod/1.0");\
       |SA-identity\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_custom_response\
       |void $*(request_rec *r, int status, char *string);\
       |r->content_type = "text/plain"; \n \
   $*(r, HTTP_FORBIDDEN, "Access denied.\n"); \
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_server_built\
       |char *$*(void);\
       |char *string;\nstring = $*();\
       |SA-identity\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_server_name\
       |char *$*(const request_rec *r);\
       |char *string;\nstring = $*();\
       |SA-identity\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_server_version\
       |char *$*(void);\
       |char *string;\nstring = $*();\
       |SA-identity\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Stuff related to the module structure
   #;
   X|SA-module\
  -    |core_module,top_module,module,ap_add_module,ap_add_named_module,ap_add_loaded_module,ap_remove_module,ap_remove_loaded_module\
  +    |core_module,top_module,module,ap_add_module,ap_add_named_module\
  +     ,ap_add_loaded_module,ap_remove_module,ap_remove_loaded_module\
       |\
       |\
       |
  @@ -194,22 +195,22 @@
       NULL                        /* post read-request */ \n \
   }; \
       |SA-module,SA-MMN,STANDARD_MODULE_STUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_add_module\
       |void $*(module *m);\
       |module mod; \n$*(mod);\
       |SA-module\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_add_loaded_module\
       |void $*(module *m);\
       |module mod; \n$*(mod);\
       |SA-module\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_add_named_module\
       |int $*(const char *name);\
       |char *modname; \nint result; \nresult = $*(modname);\
       |SA-module\
  -    |dict-$*.html
  +    |<dict-$*.html
   D|core_module\
       |module $* {<i>module-specific-info</i>};\
       |module $* = { \n \
  @@ -234,7 +235,7 @@
      NULL                         /* post_read_request */ \n \
   }; \
       |SA-module\
  -    |dict-$*.html
  +    |<dict-$*.html
   D|top_module\
       |module *$*;\
       |module *$* = NULL; \n \
  @@ -246,7 +247,7 @@
       ...do some per directory config processing... \n \
   } \
       |SA-module\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Miscellaneous data cells
   #;
  @@ -254,30 +255,30 @@
       |const char $*[7][4];\
       |if (strcmp(week, $*[wk]) == 0)\nbreak; \
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   D|ap_month_snames\
       |const char $*[12][4];\
       |if (strcmp(month, $*[mon]) == 0)\nbreak;\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   D|ap_restart_time\
       |time_t $*;\
       |    time_t nowtime = time(NULL); \n \
       time_t up_time; \n \
       up_time = nowtime - $*; \
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   D|ap_server_argv0\
       |char *$*;\
       |extern char *$*; \n$* = argv[0];\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   D|ap_server_root\
       |char $*[MAX_STRING_LEN];\
       |extern char $*[MAX_STRING_LEN]; \n \
   ap_cpystrn(ap_coredump_dir, $*, sizeof(ap_coredump_dir)); \
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   D|ap_suexec_enabled\
       |int $*;\
       |extern int $*; \n \
  @@ -288,7 +289,7 @@
       ...processing for module not using suexec features... \n \
   } \
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; MD5 digesting functions
   #;
  @@ -303,43 +304,43 @@
        elements.\
       |$* <var>identifier</var>\
       |SA-md5\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_md5\
       |char *$*(pool *a, unsigned char *string);\
       |\
       |SA-md5\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_MD5Final\
       |void $*(unsigned char digest[16], AP_MD5_CTX *context);\
       |\
       |SA-md5\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_MD5Init\
       |void $*(AP_MD5_CTX *context);\
       |\
       |SA-md5\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_MD5Update\
       |void $*(AP_MD5_CTX *context, const unsigned char *input, \
        unsigned int inputLen);\
       |\
       |SA-md5\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_md5context\
       |char *$*(pool *p, AP_MD5_CTX *context);\
       |\
       |SA-md5\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_md5digest\
       |char *$*(pool *p, FILE *infile);\
       |\
       |SA-md5\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_md5contextTo64\
       |char *$*(pool *p, AP_MD5_CTX *context);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Mutex routines
   #;
  @@ -354,31 +355,31 @@
        elements.\
       |$* <var>identifier</var>\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_acquire_mutex\
       |int $*(mutex *mutex_id);\
       |static mutex *alloc_mutex = NULL; \n \
   (void) $*(alloc_mutex);\
       |SA-mutex,SA-multi\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_create_mutex\
       |mutex *$*(char *name);\
       |static mutex *alloc_mutex = NULL; \n \
   alloc_mutex = $*(NULL);\
       |SA-mutex\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_destroy_mutex\
       |void $*(mutex *mutex_id);\
       |static mutex *start_mutex = NULL; \n \
   $*(start_mutex);\
       |SA-mutex\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_open_mutex\
       |mutex *$*(char *name);\
       |static mutex *start_mutex = NULL; \n \
   start_mutex = $*(NULL);\
       |SA-mutex\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Stuff for the scoreboard
   #;
  @@ -398,83 +399,83 @@
       ap_rputs("Dead", r); \n \
       break;\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_STARTING\
       |#define $* <var>value</var>\
       |switch (score_record.status) {\ncase $*: \n \
       ap_rputs("Starting", r); \n \
       break;\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_READY\
       |#define $* <var>value</var>\
       |switch (score_record.status) {\ncase $*: \n \
       ap_rputs("Ready", r); \n \
       break;\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_BUSY_READ\
       |#define $* <var>value</var>\
       |switch (score_record.status) {\ncase $*: \n \
       ap_rputs("&lt;B&gt;Read&lt;/B&gt;", r); \n \
       break;\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_BUSY_WRITE\
       |#define $* <var>value</var>\
       |switch (score_record.status) {\ncase $*: \n \
       ap_rputs("&lt;B&gt;Write&lt;/B&gt;", r); \n \
       break;\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_BUSY_KEEPALIVE\
       |#define $* <var>value</var>\
       |switch (score_record.status) {\ncase $*: \n \
       ap_rputs("&lt;B&gt;Keepalive&lt;/B&gt;", r); \n \
       break;\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_BUSY_LOG\
       |#define $* <var>value</var>\
       |switch (score_record.status) {\ncase $*: \n \
       ap_rputs("&lt;B&gt;Logging&lt;/B&gt;", r); \n \
       break;\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_BUSY_DNS\
       |#define $* <var>value</var>\
       |switch (score_record.status) {\ncase $*: \n \
       ap_rputs("&lt;B&gt;DNS lookup&lt;/B&gt;", r); \n \
       break;\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_GRACEFUL\
       |#define $* <var>value</var>\
       |switch (score_record.status) {\ncase $*: \n \
       ap_rputs("Graceful", r); \n \
       break;\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_NUM_STATUS\
       |#define $* <var>value</var>\
       |if (score_record.status &lt; $*) {\n    return OK;\n} \
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|START_PREQUEST\
       |#define $* <var>value</var>\
       |if (status == $*) {\n    ...deal with request start time...\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|STOP_PREQUEST\
       |#define $* <var>value</var>\
       |if (status == $*) {\n    ...deal with request stop time...\n}\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   D|ap_scoreboard_image\
       |extern scoreboard *$*;\
       |$*-&gt;global.exit_generation = 0;\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|vtime_t\
       |typedef unsigned vtime_t;\
       |short_score *ss; \n \
  @@ -491,7 +492,7 @@
       kill(ps-&gt;pid, SIGALRM); \n \
   } \
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Here comes another bunch of confusing multi-line definitions..
   #;
  @@ -508,7 +509,7 @@
       ps_record = ap_scoreboard_image-&gt;parent[i]; \n \
   } \
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|global_score\
       |typedef struct { \n \
       int exit_generation; \n \
  @@ -519,7 +520,7 @@
       $* global; \n \
   } scoreboard; \
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|short_score\
       |typedef struct { \n \
   #ifdef OPTIMIZE_TIMEOUTS \n \
  @@ -554,7 +555,7 @@
   } $*;\
       |\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|scoreboard\
       |typedef struct { \n \
       short_score servers[HARD_SERVER_LIMIT]; \n \
  @@ -563,17 +564,17 @@
   } $*;\
       |\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_sync_scoreboard_image\
       |void $*(void);\
       |$*();\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_exists_scoreboard_image\
       |int $*(void);\
       |\
       |SA-scoreboard\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Miscellaneous structures
   #;
  @@ -582,7 +583,7 @@
        elements.\
       |$* <var>identifier</var>\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|configfile_t\
       |typedef struct { \n \
       int (*getch) (void *param); \n \
  @@ -594,7 +595,7 @@
   } configfile_t;\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Reliable piped log stuff
   #;
  @@ -616,23 +617,23 @@
   } piped_log;\
       |\
       |SA-piped-log\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_close_piped_log\
       |void $*(piped_log *plp);\
       |\
       |SA-piped-log\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_open_piped_log\
       |piped_log *$*(pool *p, const char *program);\
       |\
       |SA-piped-log\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   R|ap_content_type_tolower\
       |void $*(char *str)\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Core records and data structures
   #;
  @@ -641,7 +642,7 @@
        ,proxyreqtype,server_addr_rec\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|conn_rec\
       |typedef struct conn_rec conn_rec; \n \
   struct conn_rec { \n \
  @@ -668,7 +669,7 @@
   };\
       |\
       |SA-core-rec\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|regex_t\
       |typedef struct { \n \
       int re_magic; \n \
  @@ -678,14 +679,14 @@
   } regex_t;\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|regmatch_t\
       |typedef struct {\nregoff_t rm_so;     // start of match \n \
   regoff_t rm_eo;     // end of match \n \
   } regmatch_t; \
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|request_rec\
       |typedef struct request_rec request_rec; \n \
   struct request_rec { \n \
  @@ -748,7 +749,7 @@
   };\
       |\
       |SA-core-rec,HTTP_VERSION_MAJOR,HTTP_VERSION_MINOR\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|server_addr_rec\
       |typedef struct $* $*; \n \
   struct $* { \n \
  @@ -759,7 +760,7 @@
   } \
       |\
       |SA-core-rec\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|server_rec\
       |struct server_rec { \n \
       server_rec *next; \n \
  @@ -794,7 +795,7 @@
   }; \
       |\
       |SA-core-rec\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|BUFF\
       |typedef struct buff_struct $*; \n \
   struct buff_struct { \n \
  @@ -823,7 +824,7 @@
   };\
       |\
       |SA-core-rec\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|cmd_parms\
       |typedef struct { \n \
       void *info; \n \
  @@ -839,7 +840,7 @@
   } $*;\
       |\
       |SA-core-rec,SA-overrides\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|command_rec\
       |typedef struct command_struct {\n \
       const char *name;\n \
  @@ -851,7 +852,7 @@
   } $*;\
       |\
       |SA-core-rec,SA-overrides\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Directive overrides
   #;
  @@ -872,7 +873,7 @@
       {NULL}\n\
   };\
       |SA-overrides\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|ACCESS_CONF\
       |#define $* <var>value</var>\
       |static const command_rec module_cmds[] =\n\
  @@ -884,7 +885,7 @@
       {NULL}\n\
   };\
       |SA-overrides\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OR_AUTHCFG\
       |#define $* <var>value</var>\
       |static const command_rec module_cmds[] =\n\
  @@ -896,7 +897,7 @@
       {NULL}\n\
   };\
       |SA-overrides\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OR_LIMIT\
       |#define $* <var>value</var>\
       |static const command_rec module_cmds[] =\n\
  @@ -908,7 +909,7 @@
       {NULL}\n\
   };\
       |SA-overrides\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OR_OPTIONS\
       |#define $* <var>value</var>\
       |static const command_rec module_cmds[] =\n\
  @@ -920,7 +921,7 @@
       {NULL}\n\
   };\
       |SA-overrides\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OR_FILEINFO\
       |#define $* <var>value</var>\
       |static const command_rec module_cmds[] =\n\
  @@ -932,7 +933,7 @@
       {NULL}\n\
   };\
       |SA-overrides\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OR_INDEXES\
       |#define $* <var>value</var>\
       |static const command_rec module_cmds[] =\n\
  @@ -944,7 +945,7 @@
       {NULL}\n\
   };\
       |SA-overrides\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Random constants
   #;
  @@ -958,38 +959,38 @@
       |Compile-time definition\
       |env CFLAGS="-Wall -D$*" ./configure\
       |SA-compileflags\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|DEFAULT_ADMIN\
       |Compile-time definition\
       |env CFLAGS="-Wall -D$*=\"/usr/httpd/htdocs\"" ./configure\
       |SA-compileflags\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|DOCUMENT_LOCATION\
       |Compile-time definition\
       |env CFLAGS="-Wall -D$*=\"/usr/httpd/htdocs\"" ./configure\
       |SA-compileflags,ap_document_root\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|DYNAMIC_MODULE_LIMIT\
       |Compile-time definition\
       |env CFLAGS="-Wall -D$*=64" ./configure\
       |SA-compileflags\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HARD_SERVER_LIMIT\
       |Compile-time definition\
       |env CFLAGS="-Wall -D$*=1024" ./configure \n \n \
   for (i = 0; i &lt; $*; ++i) {\n    ...per-child processing...\n}\
       |SA-compileflags\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTPD_ROOT\
       |Compile-time definition\
       |env CFLAGS="-Wall -D$*=\"/usr/httpd\"" ./configure\
       |SA-compileflags\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SECURITY_HOLE_PASS_AUTHORIZATION\
       |Compile-time definition\
       |env CFLAGS="-Wall -D$*" ./configure\
       |SA-compileflags\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Tables..
   #;
  @@ -1007,37 +1008,37 @@
        string_pairs = ap_make_table(p, 4);\n \
        ap_table_set(string_pairs, "key", "value"); \
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_clear_table\
       |void $*(table *t);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_copy_table\
       |table *$*(pool *p, const table *t);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_make_table\
       |table *$*(pool *p, int nelts);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_overlay_tables\
       |table *$*(pool *p, const table *overlay, const table *base);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_table_add\
       |void $*(table *t, const char *k, const char *val);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_table_addn\
       |void $*(table *t, const char *k, const char *val);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; Here's an example of multiline definition with proper indenting.
   #;
  @@ -1046,37 +1047,37 @@
                    void *rec, const table *t, ...);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_table_get\
       |const char *$*(const table *t, const char *key);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_table_merge\
       |void $*(table *t, const char *k, const char *more_val);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_table_mergen\
       |void $*(table *t, const char *k, const char *more_val);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_table_set\
       |void $*(table *t, const char *k, const char *val);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_table_setn\
       |void $*(table *t, const char *k, const char *val);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_table_unset\
       |void $*(table *t, const char *k);\
       |\
       |SA-tables\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; arrays..
   #;
  @@ -1117,27 +1118,27 @@
               i, item-&gt;length, item-&gt;string);\n \
   }\n \
       |SA-array\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_array_cat\
       |void $*(array_header *dst, const array_header *src);\
       |$*(&amp;res-&gt;a, &amp;base-&gt;second);\
       |SA-array\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_copy_array\
       |array_header *$*(pool *p, const array_header *src);\
       |\
       |SA-array\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_copy_array_hdr\
       |array_header *$*(pool *p, const array_header *src);\
       |\
       |SA-array\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_make_array\
       |array_header *$*(pool *p, int nelts, int elt_size);\
       |\
       |SA-array\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_push_array\
       |void *$*(array_header *arr);\
       |struct ae_t { \n \
  @@ -1150,7 +1151,7 @@
   ae = (struct ae_t *) ap_push_array(ah); \n \
   ae-&gt;s-&gt;server_name = "foo"; \
       |SA-array\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; now the items relating to pools
   #;
  @@ -1171,24 +1172,24 @@
        \nchar *foo; \
        \nfoo = ap_pstrcat(p, "string 1", "string 2", null);\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|ap_pool\
       |typedef struct pool pool;\n \
   typedef struct pool ap_pool;\n \
   struct pool <var>opaque-structure</var>\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bytes_in_pool\
       |long $*(pool *p);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_clear_pool\
       |void $*(struct pool *a);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_find_pool\
       |pool *$*(const void *ts);\
       |pool *p;\n\
  @@ -1198,117 +1199,117 @@
        * or in memory allocated using some other method than pools */ \n \
   }\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pool_is_ancestor\
       |int $*(pool *a, pool *b);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pool_join\
       |void $*(pool *p, pool *sub);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_make_sub_pool\
       |pool *$*(pool *p);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_destroy_pool\
       |void $*(pool *p);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pstrcat\
       |char *$*(struct pool *p, ...);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_palloc\
       |void *$*(struct pool *p, int nbytes);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pcalloc\
       |void *$*(struct pool *p, int nbytes);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pclosedir\
       |void $*(pool *p, dir * d);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pclosef\
       |int $*(struct pool *p, int fd);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pclosesocket\
       |int $*(pool *p, int sock);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pduphostent\
       |struct hostent *$*(pool *p, struct hostent *hp);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pfclose\
       |int $*(struct pool *p, file *f);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pfdopen\
       |file *$*(struct pool *p, int fd, const char *fmode);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pfopen\
       |file *$*(struct pool *p, const char *name, const char *fmode);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pgethostbyname\
       |struct hostent *$*(pool *p, const char *hostname);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_popendir\
       |dir *$*(pool *p, const char *name);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_popenf\
       |int $*(struct pool *p, const char *name, int flg, int mode);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pregcomp\
       |regex_t *$*(pool *p, const char *pattern, int cflags);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pregfree\
       |void $*(pool *p, regex_t *reg);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_psocket\
       |int $*(pool *p, int i, int j, int k);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pstrdup\
       |char *$*(struct pool *p, const char *s);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pstrndup\
       |char *$*(struct pool *p, const char *s, int n);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; incomplete definitions!
   #;
  @@ -1316,19 +1317,19 @@
       |array_header *$*(pool *p, const array_header *a, const array_header *b);\
       |new-&gt;hdr_list = $*(p, add-&gt;hdr_list, base-&gt;hdr_list);\
       |SA-array\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pregsub\
       |char *$*(pool *p, const char *input, const char *source, size_t nmatch, \
        regmatch_t pmatch[]);\
       |\
       |SA-pool\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_vformatter\
       |int $*(int (*flush_func)(ap_vformatter_buff *f), ap_vformatter_buff *b, \
        const char *fmt, va_list ap);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   s|ap_vformatter_buff\
       |typedef struct {\n\
       char *curpos;\n\
  @@ -1336,7 +1337,7 @@
   } ap_vformatter_buff;\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; miscellany (for now)
   #;
  @@ -1359,7 +1360,7 @@
   } $*; \
       |\
       |SA-core-rec\
  -    |dict-$*.html
  +    |<dict-$*.html
   X|SA-dirdata\
       |cmd_how,RAW_ARGS,TAKE1,TAKE2,ITERATE,ITERATE2,FLAG,NO_ARGS,TAKE12\
        ,TAKE3,TAKE23,TAKE123,TAKE13\
  @@ -1384,7 +1385,7 @@
       |The enumeration type isn't used by modules, only the specific\n \
        named values.\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|proxyreqtype\
       |enum proxyreqtype { \n \
       NOT_PROXY=0, \n \
  @@ -1393,7 +1394,7 @@
   }; \n \
       |\
       |request_rec\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|RAW_ARGS\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1405,7 +1406,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|TAKE1\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1417,7 +1418,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|TAKE2\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1429,7 +1430,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|ITERATE\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1441,7 +1442,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|ITERATE2\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1453,7 +1454,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|FLAG\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1465,7 +1466,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|NO_ARGS\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1477,7 +1478,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|TAKE12\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1489,7 +1490,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|TAKE3\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1501,7 +1502,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|TAKE23\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1513,7 +1514,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|TAKE123\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1525,7 +1526,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|TAKE13\
       |<i>see</i> cmd_how.\
       |static const command_rec module_cmds[] =\n\
  @@ -1537,7 +1538,7 @@
       {NULL}\n\
   };\
       |SA-dirdata\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; A whole buncha misc.functions
   #;
  @@ -1545,91 +1546,91 @@
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_add_common_vars\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_add_per_dir_conf\
       |void $*(server_rec *s, void *dir_config);\
       |<i>Private to the Apache core server; not for module use.</i>\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_cpystrn\
       |char *$*(char *buf, const char *str, size_t numbytes);\
       |char *ap_coredump_dir;\nchar *ap_server_root;\n$*(ap_coredump_dir, ap_server_root, sizeof(ap_coredump_dir));\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bprintf\
       |int $*(BUFF *fb, const char *fmt, ...);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_os_canonical_filename\
       |char *$*(pool *p, const char *file);\
       |request_rec *r;\nr-&gt;filename = $*(r-&gt;pool, r-&gt;filename);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_escape_quotes\
       |char *$*(pool *p, const char *str);\
       |cmd_parms *cmd;\nchar *word1;\n \
   core_dir_config *aconfig = (core_dir_config *)mconfig; \n \
   aconfig-&gt;ap_auth_name = $*(cmd-&gt;pool, word1);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_log_error_old\
       |void $*(const char *err, server_rec *s);\
       |server_rec *s;\n$*("Yow!", s);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_parse_hostinfo_components\
       |int $*(pool *p, const char *hostinfo, uri_components *uptr);\
       |request_rec *r;\nconst char *uri;\nint status; \n \
   status = $*(r-&gt;pool, uri, &amp;r-&gt;parsed_uri);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_psprintf\
       |char *$*(struct pool *p, const char *fmt, ...);\
       |pool *p;\nchar *real_code;\nchar base = 'x';\nint modifier = 0; \n \
   real_code = $*(p, "%c%d", base, modifier);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pvsprintf\
       |char *$*(struct pool *p, const char *fmt, va_list);\
       |pool *p;\nconst char *fmt;\nva_list ap;\nchar *res;\nres = $*(p, fmt, ap);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_snprintf\
       |int $*(char *buf, size_t nbytes, const char *fmt, ...);\
       |char buffer[HUGE_STRING_LEN];\nrequest_rec *r;\n \
   $*(buffer, sizeof(buffer), "connect %s http/1.0" crlf, r-&gt;uri);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_add_per_url_conf\
       |void $*(server_rec *s, void *url_config);\
       |server_rec *s;\nvoid *url_config;\n \
   $*(server_rec *s, void *url_config);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_allow_options\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       \nif (result &amp; OPT_INCLUDES) {\n \
       /* Do something meaningful and Includes-related */\n} \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_allow_overrides\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |SA-overrides\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_vsnprintf\
       |int $*(char *buf, size_t numbytes, const char *fmt, va_list ap);\
       |const char *text;\nchar str2[512];\nva_list ap;\n \
   $*(str2, sizeof(str2), text, ap);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   X|SA-security\
       |ap_auth_name,ap_auth_type,ap_validate_password\
       |\
  @@ -1641,14 +1642,14 @@
       /* no applicable security realm */ \n \
       } \n \
       |SA-security\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_auth_type\
       |const char *$*(request_rec *r);\
       |if (strcasecmp($*(r), "Basic") == 0) { \n \
       /* AuthType Basic */ \n \
   } \
       |SA-security\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_validate_password\
       |char *$*(const char *passwd, const char *hash);\
       |pwcheck = $*(pw_from_request, pw_from_file); \n \
  @@ -1661,17 +1662,17 @@
       return HTTP_UNAUTHORIZED; \n \
   } \
       |SA-security\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_basic_http_header\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   S|HANDLE\
       |Opaque data structure defined by Windows.\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   X|SA-BUFF\
       |BUFF,ap_bclose,ap_bcreate,ap_bfilbuf,ap_bfileno,ap_bflsbuf,ap_bflush\
        ,ap_bgetc\
  @@ -1689,113 +1690,113 @@
       |\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|BO_BYTECT\
       |#define $* (1)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_RD\
       |#define $* (1)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_WR\
       |#define $* (2)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_RDWR\
       |#define $* (3)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_EOF\
       |#define $* (4)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_EOUT\
       |#define $* (8)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_RDERR\
       |#define $* (16)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_WRERR\
       |#define $* (32)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_ERROR\
       |#ifdef $*\n \
   #undef $*\n \
   #define $* (48)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_CHUNK\
       |#define $* (64)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_SAFEREAD\
       |#define $* (128)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_SOCKET\
       |#define $* (256)\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_ASCII2EBCDIC\
       |#ifdef CHARSET_EBCDIC\n \
   #define $* 0x40000000\n \
   #endif\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|B_EBCDIC2ASCII\
       |#ifdef CHARSET_EBCDIC\n \
   #define $* 0x80000000\n \
   #endif\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bclose\
       |int $*(BUFF *fb);\
       |status = $*(r-&gt;connection-&gt;client);\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bcreate\
       |BUFF *$*(pool *p, int flags);\
       |c-&gt;fp = $*(p, B_RDWR &#124; B_SOCKET);\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bfilbuf\
       |int $*(BUFF *fb);\
       |SA-BUFF\
       |ap_bgetc\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bfileno\
       |int $*(BUFF *fb, int direction);\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bflsbuf\
       |int $*(int c, BUFF *fb);\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bflush\
       |int $*(BUFF *fb);\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|ap_bgetc\
       |#ifndef CHARSET_EBCDIC\n \
   #define $*(fb) ( ((fb)-&gt;incnt == 0) ? ap_bfilbuf(fb) \n \
  @@ -1810,57 +1811,57 @@
       |if ((c = $*(r-&gt;connection-&gt;client)) == CR) { \n \
       c = $*(r-&gt;connection-&gt;client);\n}\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|ap_bgetflag\
       |#define $*(fb, flag)  ((fb)-&gt;flags &amp; (flag))\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bgetopt\
       |int $*(BUFF *fb, int optname, void *optval);\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bgets\
       |int $*(char *s, int n, BUFF *fb);\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bhalfduplex\
       |void $*(BUFF *fb);\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_block_alarms\
       |void $*(void);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_blookc\
       |int $*(char *buffer, BUFF *fb);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bnonblock\
       |int $*(BUFF *fb, int direction);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bonerror\
       |void $*(BUFF *fb, void (*error) (BUFF *b, int, void *), void *data);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bpushfd\
       |void $*(BUFF *fb, int fd_in, int fd_out);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bpushh\
       |void $*(BUFF *fb, HANDLE hFH);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|ap_bputc\
       |#ifndef CHARSET_EBCDIC\n \
   #define $*(c, fb) ((((fb)-&gt;flags &amp; \
  @@ -1877,32 +1878,32 @@
   #endif\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bputs\
       |int $*(const char *x, BUFF *fb);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bread\
       |int $*(BUFF *fb, void *buf, int nbyte);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bsetflag\
       |int $*(BUFF *fb, int flag, int value);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bsetopt\
       |int $*(BUFF *fb, int optname, const void *optval);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bskiplf\
       |int $*(BUFF *fb);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bspawn_child\
       |int $*(pool *p, int (*func) (void *data, child_info *info), \n \
                       void *data, enum kill_conditions kill_how, \n \
  @@ -1910,183 +1911,183 @@
   BUFF **pipe_err);\
       |\
       |SA-BUFF\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bvputs\
       |int $*(BUFF *fb, ...);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bwrite\
       |int $*(BUFF *fb, const void *buf, int nbyte);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_bytes_in_free_blocks\
       |long $*(void);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_call_exec\
       |int $*(request_rec *r, char *argv0, char **env, int shellcmd);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_can_exec\
       |int $*(const struct stat *fstat);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_cfg_closefile\
       |int $*(configfile_t *fp);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_cfg_getc\
       |int $*(configfile_t *cfp);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_cfg_getline\
       |int $*(char *buf, size_t bufsize, configfile_t *cfp);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_chdir_file\
       |void $*(const char *file);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_check_access\
       |int $*(request_rec *);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_check_alarm\
       |int $*(void);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_check_auth\
       |int $*(request_rec *);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_check_cmd_context\
       |const char *$*(cmd_parms *cmd, unsigned forbidden);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_check_user_id\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_checkmask\
       |int $*(const char *data, const char *mask);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_child_exit_modules\
       |void $*(pool *p, server_rec *s);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_child_init_modules\
       |void $*(pool *p, server_rec *s);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_child_terminate\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_cleanup_for_exec\
       |void $*(void);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_clear_module_list\
       |void $*(void);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_construct_server\
       |char *$*(pool *p, const char *hostname, unsigned port, \
        const request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_construct_url\
       |char *$*(pool *p, const char *uri, const request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_core_reorder_directories\
       |void $*(pool *, server_rec *);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_count_dirs\
       |int $*(const char *path);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_create_environment\
       |char **$*(pool *p, table *t);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_create_per_dir_config\
       |void *$*(pool *p);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_create_request_config\
       |void *$*(pool *p);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_default_port_for_request\
       |unsigned short $*(const request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_default_port_for_scheme\
       |unsigned short $*(const char *scheme_str);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_default_type\
       |char *$*(request_req *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_destroy_sub_req\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_die\
       |void $*(int type, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_discard_request_body\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_document_root\
       |const char *$*(request_rec *r);\
       |request_rec *r;\nconst char *docroot;\ndocroot = ap_document_root(r)\n \
       |DOCUMENT_LOCATION\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_each_byterange\
       |int $*(request_rec *r, long *offset, long *length);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   X|SA-logging\
       |APLOG_ALERT,APLOG_CRIT,APLOG_DEBUG,APLOG_EMERG,APLOG_ERR,APLOG_INFO\
        ,APLOG_LEVELMASK,APLOG_MARK,APLOG_NOERRNO,APLOG_NOTICE,APLOG_WARNING\
  @@ -2098,77 +2099,77 @@
       |void $*(server_rec *s);\
       |\
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_escape_html\
       |char *$*(pool *p, const char *s);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_escape_path_segment\
       |char *$*(pool *p, const char *s);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_escape_shell_cmd\
       |char *$*(pool *p, const char *s);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_finalize_request_protocol\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_finalize_sub_req_protocol\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_find_command\
       |const command_rec *$*(const char *name, const command_rec *cmds);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_find_command_in_modules\
       |const command_rec *$*(const char *cmd_name, module **m);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_find_last_token\
       |int $*(pool *p, const char *line, const char *tok);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_find_linked_module\
       |module *$*(const char *name);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_find_module_name\
       |const char *$*(module *m);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_find_path_info\
       |int $*(const char *uri, const char *path_info);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_find_token\
       |int $*(pool *p, const char *line, const char *tok);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_find_types\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_fini_vhost_config\
       |void $*(pool *p, server_rec *main_server);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   X|SA-fnmatch\
       |ap_fnmatch,FNM_NOMATCH,FNM_NOESCAPE,FNM_PATHNAME,FNM_PERIOD\
        ,FNM_CASE_BLIND\
  @@ -2179,27 +2180,27 @@
       |#define $* 1\
       |\
       |SA-fnmatch\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|FNM_NOESCAPE\
       |#define $* 0x01\
       |\
       |SA-fnmatch\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|FNM_PATHNAME\
       |#define $* 0x02\
       |\
       |SA-fnmatch\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|FNM_PERIOD\
       |#define $* 0x04\
       |\
       |SA-fnmatch\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|FNM_CASE_BLIND\
       |#define $* 0x08\
       |\
       |SA-fnmatch\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_fnmatch\
       |int $*(const char *pattern, const char *string, int flags);\
       |#include "fnmatch.h"\n\
  @@ -2211,243 +2212,243 @@
           return OK; \n \
       }\
       |SA-fnmatch\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_force_library_loading\
       |void $*(void)\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_basic_auth_pw\
       |int $*(request_rec *r, char **pw);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_client_block\
       |long $*(request_rec *r, char *buffer, int bufsiz);\
       |\
       |SA-readbody\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_gmtoff\
       |struct tm *$*(int *tz);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_local_host\
       |char *$*(pool *);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_module_config\
       |void *$*(void *conf_vector, module *m);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_remote_host\
       |const char *$*(conn_rec *conn, void *dir_config, int type);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_remote_logname\
       |const char *$*(request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_server_port\
       |unsigned $*(const request_rec *r);\
       |const request_rec *r;\nint port;\nport = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_time\
       |char *$*(void);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_token\
       |char *$*(pool *p, char **accept_line, int accept_white);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_get_virthost_addr\
       |unsigned long $*(const char *w, unsigned short *ports);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_getparents\
       |void $*(char *name);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_getword\
       |char *$*(pool *p, const char **line, char stop);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_getword_conf\
       |char *$*(pool *p, const char **line);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_getword_conf_nc\
       |char *$*(pool *p, char **line);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_getword_nc\
       |char *$*(pool *p, char **line, char stop);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_getword_nulls\
       |char *$*(pool *p, const char **line, char stop);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_getword_nulls_nc\
       |char *$*(pool *p, char **line, char stop);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_getword_white\
       |char *$*(pool *p, const char **line);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_getword_white_nc\
       |char *$*(pool *p, char **line);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_gm_timestr_822\
       |char *$*(pool *p, time_t t);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_gname2id\
       |gid_t $*(const char *name);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_handle_command\
       |const char *$*(cmd_parms *parms, void *config, const char *l);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_hard_timeout\
       |void $*(char *reason, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_header_parse\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_ht_time\
       |char *$*(pool *p, time_t t, const char *fmt, int gmt);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_ind\
       |int $*(const char *str, char c);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_index_of_response\
       |int $*(int status);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_init_alloc\
       |pool * $*(void);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_init_modules\
       |void $*(pool *p, server_rec *s);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_init_vhost_config\
       |void $*(pool *p);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_init_virtual_host\
       |const char *$*(pool *p, const char *hostname, server_rec *main_server, \
        server_rec **);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_internal_redirect\
       |void $*(const char *new_uri, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_internal_redirect_handler\
       |void $*(const char *new_uri, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_invoke_handler\
       |int $*(request_rec *r)\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_is_directory\
       |int $*(const char *name);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_is_fnmatch\
       |int $*(const char *str);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_is_initial_req\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_is_matchexp\
       |int $*(const char *str);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_is_url\
       |int $*(const char *u);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_keepalive_timeout\
       |void $*(char *reason, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_kill_cleanup\
       |void $*(pool *p, void *data, void (*plain_cleanup) (void *));\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_kill_cleanups_for_fd\
       |void $*(pool *p, int fd);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_kill_cleanups_for_socket\
       |void $*(pool *p, int sock);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_kill_timeout\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_limit_section\
       |const char *$*(r (const char *szexp, const char *szfile, int nline);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_log_error\
       |void $*(const char *file, int line, int level, \n \
                         const server_rec *s, \
  @@ -2455,7 +2456,7 @@
                         __attribute__((format(printf,5,6)));\
       |\
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_log_rerror\
       |void $*(const char *file, int line, int level, \n \
                      const request_rec *r, \
  @@ -2463,214 +2464,214 @@
                      __attribute__((format(printf,5,6)));\
       |\
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_ALERT\
       |#define $* <var>value</var>\
       |ap_log_rerror(APLOG_MARK, APLOG_NOERRNO&#124;$*, r, "%s", message); \
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_CRIT\
       |#define $* <var>value</var>\
       |ap_log_rerror(APLOG_MARK, APLOG_NOERRNO&#124;$*, r, "%s", message); \
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_DEBUG\
       |#define $* <var>value</var>\
       |ap_log_rerror(APLOG_MARK, APLOG_NOERRNO&#124;$*, r, "%s", message); \
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_EMERG\
       |#define $* <var>value</var>\
       |ap_log_rerror(APLOG_MARK, APLOG_NOERRNO&#124;$*, r, "%s", message); \
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_ERR\
       |#define $* <var>value</var>\
       |ap_log_rerror(APLOG_MARK, APLOG_NOERRNO&#124;$*, r, "%s", message); \
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_INFO\
       |#define $* <var>value</var>\
       |ap_log_rerror(APLOG_MARK, APLOG_NOERRNO&#124;$*, r, "%s", message); \
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_NOTICE\
       |#define $* <var>value</var>\
       |ap_log_rerror(APLOG_MARK, APLOG_NOERRNO&#124;$*, r, "%s", message); \
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_WARNING\
       |#define $* <var>value</var>\
       |ap_log_rerror(APLOG_MARK, APLOG_NOERRNO&#124;$*, r, "%s", message); \
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_NOERRNO\
       |#define $* <var>value</var>\
       |ap_log_rerror(APLOG_MARK, $*&#124;APLOG_ERR, r, "%s", message); \
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_MARK\
       |#define $* __FILE__,__LINE__\
       |ap_log_rerror($*, APLOG_NOERRNO&#124;APLOG_ERR, r, "%s", message); \
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_LEVELMASK\
       |#define $* <var>value</var>\
       |\
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|APLOG_WIN32ERROR\
       |#define $* ((APLOG_LEVELMASK+1) * 2)\
       |\
       |SA-logging\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_log_pid\
       |void $*(pool *p, char *fname);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_log_printf\
       |void $*(const server_rec *s, const char *fmt, ...);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_log_reason\
       |void $*(const char *reason, const char *fname, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_log_transaction\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_log_unixerr\
       |void $*(const char *routine, const char *file, const char *msg, \
        server_rec *s);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_make_dirstr\
       |char *$*(pool *a, const char *s, int n);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_make_dirstr_parent\
       |char *$*(pool *p, const char *s);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_make_dirstr_prefix\
       |char *$*(char *d, const char *s, int n);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_make_full_path\
       |char *$*(pool *a, const char *dir, const char *f);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_matches_request_vhost\
       |int $*(request_rec *r, const char *host, unsigned port);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_meets_conditions\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_merge_per_dir_configs\
       |void *$*(pool *p, void *base, void *new);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_no2slash\
       |void $*(char *name);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_note_auth_failure\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_note_basic_auth_failure\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_note_cleanups_for_fd\
       |void $*(pool *p, int fd);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_note_cleanups_for_file\
       |void $*(pool *p, file *f);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_note_cleanups_for_socket\
       |void $*(pool *p, int sock);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_note_digest_auth_failure\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_note_subprocess\
       |void $*(pool *p, int pid, enum kill_conditions how);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_null_cleanup\
       |void $*(void *data);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_open_logs\
       |void $*(server_rec *s, pool *p);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_escape_path\
       |char *$*(pool *p, const char *path, int partial);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_os_is_path_absolute\
       |int ap_os_is_path_absolute(const char *file);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_parseHTTPdate\
       |time_t $*(const char *date);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_parse_htaccess\
       |int ap_parse_htaccess(void **result, request_rec *r, int override,\n \
           const char *path, const char *access_name); \
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_parse_uri\
       |void $*(request_rec *r, const char *uri);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_parse_uri_components\
       |int $*(pool *p, const char *uri, uri_components *uptr);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_parse_vhost_addrs\
       |const char *$*(pool *p, const char *hostname, server_rec *s);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pcfg_open_custom\
       |configfile_t *$*(pool *p, const char *descr, void *param, \
        int(*getc_func)(void*), \n \
  @@ -2679,282 +2680,282 @@
        int (*close_func) (void *a));\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_pcfg_openfile\
       |configfile_t *$*(pool *p, const char *name);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_process_request\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_process_resource_config\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_psignature\
       |const char *$*(const char *prefix, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_rationalize_mtime\
       |time_t $*(request_rec *r, time_t mtime);\
       |time_t mtime_to_use; \n \
    \n \
   mtime_to_use = $*(r, finfo.st_mtime); \
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_read_config\
       |server_rec *$*(pool *conf_pool, pool *temp_pool, char *config_name); \
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_read_request\
       |request_rec *$*(conn_rec *c);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_register_cleanup\
       |void $*(pool *p, void *data, void (*plain_cleanup) (void *), \
        void (*child_cleanup) (void *));\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_register_other_child\
       |void $*(int pid, void (*maintenance) \
        (int reason, void *data, int status), void *data, int write_fd);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_remove_loaded_module\
       |void $*(module *m);\
       |module mod; \n \
   $*(mod);\
       |SA-module\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_remove_module\
       |void $*(module *m);\
       |\
       |SA-module\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_requires\
       |array_header *$*(request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_reset_timeout\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_response_code_string\
       |char *$*(request_rec *r, int error_index);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_rfc1413\
       |char *$*(conn_rec *conn, server_rec *srv);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_rflush\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_rind\
       |int $*(const char *str, char c);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_rprintf\
       |int $*(request_rec *r, const char *fmt, ...);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_rputc\
       |int $*(int c, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_rputs\
       |int $*(const char *str, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_run_cleanup\
       |void $*(pool *p, void *data, void (*cleanup) (void *));\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_run_fixups\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_run_post_read_request\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_run_sub_req\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_rvputs\
       |int $*(request_rec *r, ...);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_rwrite\
       |int $*(const void *buf, int nbyte, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_satisfies\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_scan_script_header_err\
       |int $*(request_rec *r, file *f, char *buffer);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_scan_script_header_err_buff\
       |int $*(request_rec *r, BUFF *f, char *buffer);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_error_response\
       |void $*(request_rec *r, int recursive_error);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_fb\
       |long $*(BUFF *f, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_fb_length\
       |long $*(BUFF *f, request_rec *r, long length);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_fd\
       |long $*(file *f, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_fd_length\
       |long $*(file *f, request_rec *r, long length);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_header_field\
       |int $*(request_rec *r, const char *fieldname, const char *fieldval);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_http_header\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_http_options\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_http_trace\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_mmap\
       |size_t $*(void *mm, request_rec *r, size_t offset, size_t length);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_send_size\
       |void $*(size_t size, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_server_root_relative\
       |char *$*(pool *p, char *fname);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_byterange\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_callback_and_alarm\
       |unsigned int $*(void (*fn) (int), int x);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_content_length\
       |int $*(request_rec *r, long length);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_etag\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_file_slot\
       |const char *$*(cmd_parms *cmd, char *s1, char *s2);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_flag_slot\
       |const char *$*(cmd_parms *cmd, char *s1, int flag);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_keepalive\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_last_modified\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_module_config\
       |void $*(void *conf_vector, module *m, void *val);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_name_virtual_host\
       |const char *$*(cmd_parms *cmd, void *dummy, char *arg);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_string_slot\
       |const char *$*(cmd_parms *cmd, char *s1, char *s2);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_string_slot_lower\
       |const char *$*(cmd_parms *cmd, char *s1, char *s2);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_set_sub_req_protocol\
       |void $*(request_rec *rnew, const request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   X|SA-readbody\
       |ap_get_client_block,ap_setup_client_block,REQUEST_NO_BODY\
        ,REQUEST_CHUNKED_ERROR,REQUEST_CHUNKED_DECHUNK,REQUEST_CHUNKED_PASS\
  @@ -2965,189 +2966,189 @@
       |#define $* 0\
       |\
       |SA-readbody\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|REQUEST_CHUNKED_ERROR\
       |#define $* 1\
       |\
       |SA-readbody\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|REQUEST_CHUNKED_DECHUNK\
       |#define $* 2\
       |\
       |SA-readbody\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|REQUEST_CHUNKED_PASS\
       |#define $* 3\
       |\
       |SA-readbody\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_setup_client_block\
       |int $*(request_rec *r, int read_policy);\
       |\
       |SA-readbody\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_setup_prelinked_modules\
       |void $*(void);\
       |$*();\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_should_client_block\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_show_directives\
       |void $*(void);\
       |$*();\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_show_modules\
       |void $*(void);\
       |$*();\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_soft_timeout\
       |void $*(char *str, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_some_auth_required\
       |int $*(request_rec *r);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_spawn_child_err\
       |int $*(pool *p, int (*func)(void *), void *data, enum kill_conditions, \
        FILE **pipe_in, FILE **pipe_out, FILE **pipe_err);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_spawn_child_err_buff\
       |int $*(pool *p, int (*func)(void *), void *data, enum kill_conditions, \n \
                               BUFF **pipe_in, BUFF **pipe_out, BUFF **pipe_err);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_srm_command_loop\
       |const char *$*(cmd_parms *parms, void *config);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_start_restart\
       |void $*(int);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_start_shutdown\
       |void $*(void);\
       |$*();\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_str_tolower\
       |void $*(char *str);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_strcasecmp_match\
       |int $*(const char *str, const char *exp);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_strcmp_match\
       |int $*(const char *str, const char *exp);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_sub_req_lookup_file\
       |request_rec *$*(const char *new_file, const request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_sub_req_lookup_uri\
       |request_rec *$*(const char *new_file, const request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_time_process_request\
       |void $*(int child_num, int status);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_tm2sec\
       |time_t $*(const struct tm *t);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_translate_name\
       |int $*(request_rec *);\
       |request_rec *r;\nint result;\nresult = $*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_uname2id\
       |uid_t $*(const char *name);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_unblock_alarms\
       |void $*(void);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_unescape_url\
       |int $*(char *url);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_unparse_uri_components\
       |char *$*(pool *p, const uri_components *uptr, unsigned flags);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_unregister_other_child\
       |void $*(void *data);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_update_child_status\
       |int $*(int child_num, int status, request_rec *r);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_update_mtime\
       |time_t $*(request_rec *r, time_t dependency_mtime);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_update_vhost_from_headers\
       |void $*(request_rec *r);\
       |request_rec *r;\n$*(r);\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_update_vhost_given_ip\
       |void $*(conn_rec *conn);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_util_init\
       |void $*(void);\
       |$*();\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_util_uri_init\
       |void $*(void);\
       |$*();\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_uudecode\
       |char *$*(pool *p, const char *str);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   R|ap_vbprintf\
       |int $*(BUFF *fb, const char *fmt, va_list vlist);\
       |\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; More miscellaneous contant definitions
   #;
  @@ -3167,7 +3168,7 @@
   #endif \
       |eol = strchr(string, CR);\
       |SA-stringconst\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|LF\
       |#ifndef CHARSET_EBCDIC \n \
   #define $* 10 \n \
  @@ -3176,7 +3177,7 @@
   #endif \
       |*++string = LF;\
       |SA-stringconst\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|CRLF\
       |#ifndef CHARSET_EBCDIC \n \
   #define $* "\015\013" \n \
  @@ -3185,20 +3186,20 @@
   #endif \
       |entity = strstr(request, CRLF CRLF) + (2 * strlen(CRLF));\
       |SA-stringconst\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|HTTP_VERSION_MAJOR\
       |#define $*(number) ((number)/1000)\
       |if (HTTP_VERSION_MAJOR(r-&gt;proto_num) &lt; 1) {\n \
       /* Protocol version is less than 1.0 */\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|HTTP_VERSION_MINOR\
       |#define $*(number) ((number)%1000)\
       |if (($*(r-&gt;proto_num) &gt;= 1)\n        &amp;&amp; \
       ($*(r-&gt;proto_num) &gt; 1)) {\n \
       /* Protocol version is greater than 1.1 */\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|OS_ASC\
       |#ifndef CHARSET_EBCDIC \n \
   #define $*(c) (c) \n \
  @@ -3207,22 +3208,22 @@
   #endif \
       |\
       |SA-stringconst\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|MAX_STRING_LEN\
       |#define $* <var>numbytes</var>\
       |char random_string[$*];\
       |SA-stringconst\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HUGE_STRING_LEN\
       |#define $* <var>numbytes</var>\
       |char random_string[$*];\
       |SA-stringconst\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_VERSION\
       |#define $* <var>string</var>\
       |Deprecated; use ap_get_server_version() instead.\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|kill_conditions\
       |enum $* { \n \
       kill_never, \n \
  @@ -3233,7 +3234,7 @@
   };\
       |struct process_chain *p;\np-&gt;kill_how = kill_never; \
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   X|SA-MMN\
       |MODULE_MAGIC_NUMBER,MODULE_MAGIC_NUMBER_MAJOR,MODULE_MAGIC_NUMBER_MINOR\
        ,MODULE_MAGIC_COOKIE,MODULE_MAGIC_AT_LEAST,AP_MODULE_MAGIC_AT_LEAST\
  @@ -3245,22 +3246,22 @@
       |#define $* <var>monotonically-increasing-value</var>\
       |module *m;\nif (m-&gt;version != $*)\n    exit(1);\n}\
       |SA-MMN\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|MODULE_MAGIC_NUMBER_MAJOR\
       |#define $* <var>integer-value</var>\
       |\
       |SA-MMN\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|MODULE_MAGIC_NUMBER_MINOR\
       |#define $* <var>integer-value</var>\
       |\
       |SA-MMN\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|MODULE_MAGIC_COOKIE\
       |#define $* <var>opaque-value</var>\
       |\
       |SA-MMN\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|AP_MODULE_MAGIC_AT_LEAST\
       |#define $*(major,minor)           \ \n \
       ((major) &lt; MODULE_MAGIC_NUMBER_MAJOR                \ \n \
  @@ -3278,13 +3279,13 @@
       *y = '\0'; \n \
   #endif\
       |SA-MMN\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|MODULE_MAGIC_AT_LEAST\
       |<i>Obsolete</i>\
       |\
       |SA-MMN\
  -    |dict-$*.html
  -M|STANDARD_MODULE_STUFF\
  +    |<dict-$*.html
  +C|STANDARD_MODULE_STUFF\
       |#define $*  MODULE_MAGIC_NUMBER_MAJOR, \ \n \
                                  MODULE_MAGIC_NUMBER_MINOR, \ \n \
                                  -1, \ \n \
  @@ -3294,12 +3295,12 @@
                                  MODULE_MAGIC_COOKIE \
       |\
       |SA-MMN\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|SERVER_SUPPORT\
       |#define $* "http://www.apache.org/"\
       |ap_snprintf(buf, sizeof(buf), "For further assistance, go to $*");\
       |\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; The values that module hooks can return.  These have special meanings;
   #; real failures are indicated by using the HTTP_xxx values mentioned
  @@ -3316,28 +3317,28 @@
       return $*; \n \
   } \
       |SA-dirstat\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|DECLINED\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (is_HTTP_ERROR(r-&gt;status)) { \n \
       return $*; \n \
   } \
       |SA-dirstat\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|DECLINE_CMD\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (! our_cmd) { \n \
       return $*; \n \
   } \
       |SA-dirstat\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|DONE\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (!is_HTTP_ERROR(r-&gt;status)) { \n \
       return $*; \n \
   } \
       |SA-dirstat\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; HTTP status code declarations.
   #;
  @@ -3368,232 +3369,232 @@
       |#define $* 100\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_SWITCHING_PROTOCOLS\
       |#define $* 101\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_PROCESSING\
       |#define $* 102\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_OK\
       |#define $* 200\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_CREATED\
       |#define $* 201\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_ACCEPTED\
       |#define $* 202\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_NON_AUTHORITATIVE\
       |#define $* 203\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_NO_CONTENT\
       |#define $* 204\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_RESET_CONTENT\
       |#define $* 205\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_PARTIAL_CONTENT\
       |#define $* 206\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_MULTIPLE_CHOICES\
       |#define $* 300\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_MOVED_PERMANENTLY\
       |#define $* 301\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_MOVED_TEMPORARILY\
       |#define $* 302\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_SEE_OTHER\
       |#define $* 303\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_NOT_MODIFIED\
       |#define $* 304\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_USE_PROXY\
       |#define $* 305\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_BAD_REQUEST\
       |#define $* 400\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_UNAUTHORIZED\
       |#define $* 401\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_PAYMENT_REQUIRED\
       |#define $* 402\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_FORBIDDEN\
       |#define $* 403\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_NOT_FOUND\
       |#define $* 404\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_METHOD_NOT_ALLOWED\
       |#define $* 405\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_NOT_ACCEPTABLE\
       |#define $* 406\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_PROXY_AUTHENTICATION_REQUIRED\
       |#define $* 407\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_REQUEST_TIME_OUT\
       |#define $* 408\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_CONFLICT\
       |#define $* 409\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_GONE\
       |#define $* 410\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_LENGTH_REQUIRED\
       |#define $* 411\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_PRECONDITION_FAILED\
       |#define $* 412\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_REQUEST_ENTITY_TOO_LARGE\
       |#define $* 413\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_REQUEST_URI_TOO_LARGE\
       |#define $* 414\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_UNSUPPORTED_MEDIA_TYPE\
       |#define $* 415\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_RANGE_NOT_SATISFIABLE\
       |#define $* 416\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_EXPECTATION_FAILED\
       |#define $* 417\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_UNPROCESSABLE_ENTITY\
       |#define $* 422\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_LOCKED\
       |#define $* 423\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_FAILED_DEPENDENCY\
       |#define $* 424\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_INTERNAL_SERVER_ERROR\
       |#define $* 500\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_NOT_IMPLEMENTED\
       |#define $* 501\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_BAD_GATEWAY\
       |#define $* 502\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_SERVICE_UNAVAILABLE\
       |#define $* 503\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_GATEWAY_TIME_OUT\
       |#define $* 504\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_VERSION_NOT_SUPPORTED\
       |#define $* 505\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_VARIANT_ALSO_VARIES\
       |#define $* 506\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_INSUFFICIENT_STORAGE\
       |#define $* 507\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|HTTP_NOT_EXTENDED\
       |#define $* 510\
       |request_rec *r;\nif (r-&gt;status == $*) {\n    ...processing for $* status...\n}\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   #; Multithread stuff
   X|SA-multi\
       |ap_acquire_mutex,MULTI_OK,MULTI_ERR,MULTI_TIMEOUT\
  @@ -3618,7 +3619,7 @@
       return(0); \n \
   } \
       |SA-multi\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|MULTI_TIMEOUT\
       |#define $* <var>value</var>\
       |static int\nmap_rv(int rv)\n{ \n \
  @@ -3637,7 +3638,7 @@
       return(0); \n \
   } \
       |SA-multi\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|MULTI_ERR\
       |#define $* <var>value</var>\
       |static int\nmap_rv(int rv)\n{ \n \
  @@ -3656,7 +3657,7 @@
       return(0); \n \
   } \
       |SA-multi\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; These are macros, but they are invoked as though they were routines -
   #; so that's how we list them.
  @@ -3665,49 +3666,49 @@
       |#define $*(major,minor) (1000*(major)+(minor))\
       |\
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|ap_is_HTTP_INFO\
       |#define $*(x) (((x) &gt;= 100) &amp;&amp; ((x) &lt; 200))\
       |request_rec *r;\nif (!$*(r-&gt;status)) { \n \
       return OK; \n \
   } \
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|ap_is_HTTP_SUCCESS\
       |#define $*(x) (((x) &gt;= 200) &amp;&amp; ((x) &lt; 300))\
       |request_rec *r;\nif (!$*(r-&gt;status)) { \n \
       return OK; \n \
   } \
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|ap_is_HTTP_REDIRECT\
       |#define $*(x) (((x) &gt;= 300) &amp;&amp; ((x) &lt; 400))\
       |request_rec *r;\nif (!$*(r-&gt;status)) { \n \
       return OK; \n \
   } \
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|ap_is_HTTP_ERROR\
       |#define $*(x) (((x) &gt;= 400) &amp;&amp; ((x) &lt; 600))\
       |request_rec *r;\nif (!$*(r-&gt;status)) { \n \
       return DONE; \n \
   } \
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|ap_is_HTTP_CLIENT_ERROR\
       |#define $*(x) (((x) &gt;= 400) &amp;&amp; ((x) &lt; 500))\
       |request_rec *r;\nif (!$*(r-&gt;status)) { \n \
       return DONE; \n \
   } \
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   M|ap_is_HTTP_SERVER_ERROR\
       |#define $*(x) (((x) &gt;= 500) &amp;&amp; ((x) &lt; 600))\
       |request_rec *r;\nif (!$*(r-&gt;status)) { \n \
       return DONE; \n \
   } \
       |SA-httpcodes\
  -    |dict-$*.html
  +    |<dict-$*.html
   #;
   #; This is another messy definition; the spacing has to be done
   #; correctly for horizontal alignment in the final <PRE> block.
  @@ -3725,54 +3726,54 @@
       /* No Options keywords are active for this location */\n} \
       return DECLINED;\n} \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OPT_INDEXES\
       |#define $* <var>value</var>\
       |if (ap_allow_options(r) &amp; $*) {\n \
       /* Options [+]Indexes covers this location */\n} \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OPT_INCLUDES\
       |#define $* <var>value</var>\
       |if (ap_allow_options(r) &amp; $*) {\n \
       /* Options [+]Includes covers this location */\n} \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OPT_SYM_LINKS\
       |#define $* <var>value</var>\
       |if (ap_allow_options(r) &amp; $*) {\n \
       /* Options [+]FollowSymLinks covers this location */\n} \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OPT_EXECCGI\
       |#define $* <var>value</var>\
       |if (ap_allow_options(r) &amp; $*) {\n \
       /* Options [+]ExecCGI covers this location */\n} \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OPT_UNSET\
       |#define $* <var>value</var>\
       |/* This value and its meaning are private to the core server. */ \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OPT_INCNOEXEC\
       |#define $* <var>value</var>\
       |if (ap_allow_options(r) &amp; $*) {\n \
       /* Options [+]IncludesNoExec covers this location */\n} \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OPT_SYM_OWNER\
       |#define $* <var>value</var>\
       |if (ap_allow_options(r) &amp; $*) {\n \
       /* Options [+]SymLinksIfOwnerMatch covers this location */\n} \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OPT_MULTI\
       |#define $* <var>value</var>\
       |if (ap_allow_options(r) &amp; $*) {\n \
       /* Options [+]MultiViews covers this location */\n} \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|OPT_ALL\
       |#define $* (OPT_INDEXES&#124;OPT_INCLUDES&#124;OPT_SYM_LINKS&#124;OPT_EXECCGI)\
       |if ((ap_allow_options(r) &amp; $*) == $*) {\n \
  @@ -3781,7 +3782,7 @@
          [+]FollowSymLinks\n \
        */\n} \
       |SA-options\
  -    |dict-$*.html
  +    |<dict-$*.html
   X|SA-methods\
       |M_GET,M_PUT,M_POST,M_DELETE,M_CONNECT,M_OPTIONS,M_TRACE,M_PATCH,\
        ,M_PROPFIND,M_MKCOL,M_COPY,M_MOVE,M_LOCK,M_UNLOCK,M_INVALID\
  @@ -3793,88 +3794,481 @@
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_PUT\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_POST\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_DELETE\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_CONNECT\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_OPTIONS\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_TRACE\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_PATCH\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_PROPFIND\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_MKCOL\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_COPY\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_MOVE\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_LOCK\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_UNLOCK\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
   C|M_INVALID\
       |#define $* <var>value</var>\
       |request_rec *r;\nif (r-&gt;method_number == $*) {\n \
       return HTTP_METHOD_NOT_ALLOWED;\n} \
       |SA-methods\
  -    |dict-$*.html
  +    |<dict-$*.html
  +#;
  +#; Definitions added by APIdict at 2000-09-15 23:32
  +#;
  +C|ap_daemons_limit\
  +    |int $*;\
  +    |\
  +    |\
  +    |
  +C|ap_daemons_max_free\
  +    |int $*;\
  +    |\
  +    |\
  +    |
  +C|ap_daemons_min_free\
  +    |int $*;\
  +    |\
  +    |\
  +    |
  +C|ap_daemons_to_start\
  +    |int $*;\
  +    |\
  +    |\
  +    |
  +C|ap_excess_requests_per_child\
  +    |int $*;\
  +    |\
  +    |\
  +    |
  +C|ap_extended_status\
  +    |int $*;\
  +    |\
  +    |\
  +    |
  +C|ap_group_id\
  +    |gid_t $*;\
  +    |\
  +    |\
  +    |
  +C|ap_loaded_modules\
  +    |module **$*;\
  +    |\
  +    |\
  +    |
  +C|ap_max_requests_per_child\
  +    |int $*;\
  +    |\
  +    |\
  +    |
  +C|ap_my_generation\
  +    |ap_generation_t volatile $*;\
  +    |\
  +    |\
  +    |
  +C|ap_pid_fname\
  +    |char *$*;\
  +    |\
  +    |\
  +    |
  +C|ap_scoreboard_fname\
  +    |char *$*;\
  +    |\
  +    |\
  +    |
  +C|ap_server_confname\
  +    |char $*[MAX_STRING_LEN];\
  +    |\
  +    |\
  +    |
  +C|ap_standalone\
  +    |int $*;\
  +    |\
  +    |\
  +    |
  +C|ap_threads_per_child\
  +    |int $*;\
  +    |\
  +    |\
  +    |
  +C|ap_user_id\
  +    |uid_t $*;\
  +    |\
  +    |\
  +    |
  +C|ap_user_name\
  +    |char *$*;\
  +    |\
  +    |\
  +    |
  +R|ap_MD5Encode\
  +    |void $*(const unsigned char *password, const unsigned char *salt, char *result, size_t nbytes);\
  +    |\
  +    |\
  +    |
  +R|ap_SHA1Final\
  +    |void $*(unsigned char digest[SHA_DIGESTSIZE], AP_SHA1_CTX *context);\
  +    |\
  +    |\
  +    |
  +R|ap_SHA1Init\
  +    |void $*(AP_SHA1_CTX *context);\
  +    |\
  +    |\
  +    |
  +R|ap_SHA1Update\
  +    |void $*(AP_SHA1_CTX *context, const char *input, unsigned int inputLen);\
  +    |\
  +    |\
  +    |
  +R|ap_SHA1Update_binary\
  +    |void $*(AP_SHA1_CTX *context, const unsigned char *input, unsigned int inputLen);\
  +    |\
  +    |\
  +    |
  +R|ap_array_pstrcat\
  +    |char *$*(pool *p, const array_header *arr, const char sep);\
  +    |\
  +    |\
  +    |
  +R|ap_base64decode\
  +    |int $*(char *plain_dst, const char *coded_src);\
  +    |\
  +    |\
  +    |
  +R|ap_base64decode_binary\
  +    |int $*(unsigned char *plain_dst, const char *coded_src);\
  +    |\
  +    |\
  +    |
  +R|ap_base64decode_len\
  +    |int $*(const char *coded_src);\
  +    |\
  +    |\
  +    |
  +R|ap_base64encode\
  +    |int $*(char *coded_dst, const char *plain_src, int len_plain_src);\
  +    |\
  +    |\
  +    |
  +R|ap_base64encode_binary\
  +    |int $*(char *coded_dst, const unsigned char *plain_src, int len_plain_src);\
  +    |\
  +    |\
  +    |
  +R|ap_base64encode_len\
  +    |int $*(int len);\
  +    |\
  +    |\
  +    |
  +R|ap_exists_config_define\
  +    |int $*(char *name);\
  +    |\
  +    |\
  +    |
  +R|ap_find_list_item\
  +    |int $*(pool *p, const char *line, const char *tok);\
  +    |\
  +    |\
  +    |
  +R|ap_get_limit_req_body\
  +    |unsigned long $*(const request_rec *r);\
  +    |\
  +    |\
  +    |
  +R|ap_get_list_item\
  +    |char *$*(pool *p, const char **field);\
  +    |\
  +    |\
  +    |
  +R|ap_get_win32_interpreter\
  +    |file_type_e $*(const request_rec *, char **);\
  +    |\
  +    |\
  +    |
  +R|ap_getpass\
  +    |int $*(const char *prompt, char *pwbuf, size_t bufsiz);\
  +    |\
  +    |\
  +    |
  +R|ap_log_assert\
  +    |void $*(const char *szExp, const char *szFile, int nLine) __attribute__((noreturn));\
  +    |\
  +    |\
  +    |
  +R|ap_make_etag\
  +    |char *$*(request_rec *r, int force_weak);\
  +    |\
  +    |\
  +    |
  +R|ap_md5_binary\
  +    |char *$*(pool *a, const unsigned char *buf, int len);\
  +    |\
  +    |\
  +    |
  +R|ap_method_number_of\
  +    |int $*(const char *method);\
  +    |\
  +    |\
  +    |
  +R|ap_note_cleanups_for_h\
  +    |void $*(pool *, HANDLE);\
  +    |\
  +    |\
  +    |
  +R|ap_os_case_canonical_filename\
  +    |char *$*(pool *pPool, const char *szFile);\
  +    |\
  +    |\
  +    |
  +R|ap_os_escape_path\
  +    |char *$*(pool *p, const char *path, int partial);\
  +    |\
  +    |\
  +    |
  +R|ap_os_is_filename_valid\
  +    |int $*(const char *file);\
  +    |\
  +    |\
  +    |
  +R|ap_os_systemcase_filename\
  +    |char *$*(pool *pPool, const char *szFile);\
  +    |\
  +    |\
  +    |
  +R|ap_overlap_tables\
  +    |void $*(table *a, const table *b, unsigned flags);\
  +    |\
  +    |\
  +    |
  +R|ap_pbase64decode\
  +    |char *$*(pool *p, const char *bufcoded);\
  +    |\
  +    |\
  +    |
  +R|ap_pbase64encode\
  +    |char *$*(pool *p, char *string);\
  +    |\
  +    |\
  +    |
  +R|ap_pcloseh\
  +    |int $*(struct pool *, HANDLE hDevice);\
  +    |\
  +    |\
  +    |
  +R|ap_regerror\
  +    |size_t $*(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size);\
  +    |\
  +    |\
  +    |
  +R|ap_regexec\
  +    |int $*(const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags);\
  +    |\
  +    |\
  +    |
  +R|ap_registry_get_server_root\
  +    |int $*(pool *p, char *dir, int size);\
  +    |\
  +    |\
  +    |
  +R|ap_registry_get_service_conf\
  +    |int $*(pool *p, char *dir, int size, char *display_name);\
  +    |\
  +    |\
  +    |
  +R|ap_registry_set_service_conf\
  +    |int $*(char *dir, char *display_name);\
  +    |\
  +    |\
  +    |
  +R|ap_release_mutex\
  +    |int $*(mutex *mutex_id);\
  +    |\
  +    |\
  +    |
  +R|ap_remove_spaces\
  +    |void $*(char *dest, char *src);\
  +    |\
  +    |\
  +    |
  +R|ap_scan_script_header_err_core\
  +    |int $*(request_rec *r, char *buffer, int(*getsfunc)(char *, int, void *), void *getsfunc_data);\
  +    |\
  +    |\
  +    |
  +R|ap_sha1_base64\
  +    |void $*(const char *clear, int len, char *out);\
  +    |\
  +    |\
  +    |
  +R|ap_size_list_item\
  +    |const char *$*(const char **field, int *len);\
  +    |\
  +    |\
  +    |
  +R|ap_spawn_child\
  +    |int $*(pool *, int(*)(void *, child_info *), void *, enum kill_conditions, FILE **pipe_in, FILE **pipe_out, FILE **pipe_err);\
  +    |\
  +    |\
  +    |
  +R|ap_strcasestr\
  +    |char *$*(const char *s1, const char *s2);\
  +    |\
  +    |\
  +    |
  +R|ap_sub_req_method_uri\
  +    |request_rec *$*(const char *method, const char *new_file, const request_rec *r);\
  +    |\
  +    |\
  +    |
  +R|ap_to64\
  +    |void $*(char *s, unsigned long v, int n);\
  +    |\
  +    |\
  +    |
  +R|ap_uuencode\
  +    |char *$*(pool *p, char *string);\
  +    |\
  +    |\
  +    |
  +R|ap_vrprintf\
  +    |int $*(request_rec *r, const char *fmt, va_list vlist);\
  +    |\
  +    |\
  +    |
  +R|ascii2ebcdic\
  +    |void *$*(void *dest, const void *srce, size_t count);\
  +    |\
  +    |\
  +    |
  +R|closedir\
  +    |int $*(DIR *);\
  +    |\
  +    |\
  +    |
  +R|ebcdic2ascii\
  +    |void *$*(void *dest, const void *srce, size_t count);\
  +    |\
  +    |\
  +    |
  +R|opendir\
  +    |DIR *$*(const char *);\
  +    |\
  +    |\
  +    |
  +R|os_spawnle\
  +    |int $*(int mode, const char *cmdname, ...);\
  +    |\
  +    |\
  +    |
  +R|os_spawnv\
  +    |int $*(int mode, const char *cmdname, const char *const *argv);\
  +    |\
  +    |\
  +    |
  +R|os_spawnve\
  +    |int $*(int mode, const char *cmdname, const char *const *argv, const char *const *envp);\
  +    |\
  +    |\
  +    |
  +R|os_stat\
  +    |int $*(const char *szPath, struct stat *pStat);\
  +    |\
  +    |\
  +    |
  +R|os_strftime\
  +    |int $*(char *s, size_t max, const char *format, const struct tm *tm);\
  +    |\
  +    |\
  +    |
  +R|readdir\
  +    |struct dirent *$*(DIR *);\
  +    |\
  +    |\
  +    |
  +R|regcomp\
  +    |int $*(regex_t *, const char *, int);\
  +    |\
  +    |\
  +    |
  +R|regerror\
  +    |size_t $*(int, const regex_t *, char *, size_t);\
  +    |\
  +    |\
  +    |
  +R|regexec\
  +    |int $*(const regex_t *, const char *, size_t, regmatch_t [], int);\
  +    |\
  +    |\
  +    |
  +R|regfree\
  +    |void $*(regex_t *);\
  +    |\
  +    |\
  +    |
  
  
  
  1.3       +5 -1      httpd-docs-1.3/apidoc/dict-top_module.html
  
  Index: dict-top_module.html
  ===================================================================
  RCS file: /home/cvs/httpd-docs-1.3/apidoc/dict-top_module.html,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -u -r1.2 -r1.3
  --- dict-top_module.html	2000/07/24 22:14:02	1.2
  +++ dict-top_module.html	2000/09/18 01:58:02	1.3
  @@ -1,3 +1,7 @@
   <p>
  -This global module structure will be first in the non-core module list.
  +The server maintains a list of active modules, which it references
  +when going through the various configuration and request processing
  +phases.  The list is actually a linked list of all of the
  +<code>module</code> structures; this global cell points to the
  +first structure in the list.
   </p>
  
  
  
  1.16      +58 -182   httpd-docs-1.3/apidoc/mkapidict
  
  Index: mkapidict
  ===================================================================
  RCS file: /home/cvs/httpd-docs-1.3/apidoc/mkapidict,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -u -r1.15 -r1.16
  --- mkapidict	2000/07/27 10:06:56	1.15
  +++ mkapidict	2000/09/18 01:58:02	1.16
  @@ -33,6 +33,9 @@
   #
   # Edit history:
   #
  +#  2000-09-16 Ken Coar
  +#	Reworked to use the APIdict.pm module, to which a lot of the
  +#	file reading/writing functionality has been moved.
   #  2000-07-23 Ken Coar
   #	Fix up the handling of '\\' in the formatter.  Also added
   #	messages when description files are missing or not specified.
  @@ -60,6 +63,8 @@
   #       Prototyped..
   #
   
  +use APIdict;
  +
   #
   # Make sure that anything we utter to stderr shows up instanter..
   #
  @@ -68,11 +73,6 @@
   select($tfh);
   
   $command_line = join(" ", $0, @ARGV);
  -%Prefix = ('R' => 'Routine',
  -	   'M' => 'Macro',
  -	   'C' => 'Constant',
  -	   'S' => 'Structure',
  -	   'D' => 'Global Data Cell');
   use Getopt::Std;
   
   @errors = ();
  @@ -120,16 +120,10 @@
       exit(1);
   }
   
  -open *dfh, "<$Dfile" || die "Can't open definition file $Dfile";
  +$dict = new APIdict($Dfile);
   
   $OutFile = "$InFile.bak";
   
  -%Routine = ();
  -%Constant = ();
  -%Structure = ();
  -%Cell = ();
  -%Entity = ();
  -%SeeAlso = ();
   %URL = ();
   %HREF = ();
   @Prologue = ();
  @@ -166,59 +160,9 @@
   close INFILE;
   close OUTFILE;
   
  -$DataLine = 0;
  -$RecordNum = 0;
  -$Continuing = 0;
  -
  -&verbose("Reading definition file.");
  -while (! eof(*dfh)) {
  -    local (@field) = ("", "", "", "", "", "", "", "");
  -    local ($rec);
  -
  -    $rec = &get_record(1);
  -    next if (! $rec);
  -    chomp($rec);
  -    @field = split(m:\|:, $rec);
  -    $rec =~ s:\$\*:$field[1]:g;
  -    @field = split(m:\|:, $rec, -1);
  -    if ($#field != 5) {
  -	if ($#field < 5) {
  -	    $dir = "few";
  -	}
  -	else {
  -	    $dir = "many";
  -	}
  -	print STDERR "$0: Too $dir fields (", ($#field + 1), " instead of 6) "
  -	    . "for record $RecordNum at line $DataLine\n";
  -    }
  -    if ($field[0] !~ m:^[RMSCDX]$:i) {
  -	print STDERR "$0: Unrecognised record identifier /$field[0]/ ",
  -		     "for record ending on line $DataLine;\n",
  -	             "\tmissing continuation character?\n";
  -	next;
  -    }
  -    if ($Entity{$field[1]}) {
  -	print STDERR "$0: Entity $field[1] redefined at line $DataLine.\n";
  -    }
  -    $Entity{$field[1]} = 1;
  -    $rtype = uc(substr($field[0], 0, 1));
  -    if ($rtype =~ /M|R/) {
  -	$Routine{$field[1]} = $rec;
  -    }
  -    elsif ($rtype eq 'S') {
  -	$Structure{$field[1]} = $rec;
  -    }
  -    elsif ($rtype eq 'C') {
  -	$Constant{$field[1]} = $rec;
  -    }
  -    elsif ($rtype eq 'D') {
  -	$Cell{$field[1]} = $rec;
  -    }
  -    elsif ($rtype eq 'X') {
  -	$SeeAlso{$field[1]} = $field[2];
  -    }
  -    $URL{"$field[1]"} = &makeURL($field[1], %URL);
  -    $HREF{"$field[1]"} = &makeHREF($field[1], %URL);
  +foreach $item ($dict->entity_list()) {
  +    $URL{$item} = &makeURL($item, %URL);
  +    $HREF{$item} = &makeHREF($item, %URL);
   }
   
   #
  @@ -226,7 +170,7 @@
   #
   &verbose("Dumping prologue.");
   foreach $line (@Prologue) {
  -    $line =~ s"(\$Generated by:).*\$"\1 $command_line \$";
  +    $line =~ s"(\$Generated by:).*\$"$1 $command_line \$";
       print $ofh $line;
   }
   print $ofh <<EOHT;
  @@ -246,11 +190,12 @@
   EOHT
   
   &verbose("Analysing routines: \\c");
  -&list_items('R', %Routine);
  -@keys = keys(%Routine);
  +@keys = $dict->routine_list();
  +push(@keys, $dict->macro_list());
  +&list_items(@keys);
   &verbose(($#keys + 1) . " found.");
   &verbose("Dumping routines.");
  -&dump_list('R', %Routine);
  +&dump_list('R', @keys);
   
   print $ofh <<EOHT;
     <h2><a name="Structures">Data Structure Definitions</a></h2>
  @@ -258,8 +203,8 @@
   EOHT
   
   &verbose("Analysing structures: \\c");
  -&list_items('S', %Structure);
  -@keys = keys(%Structure);
  +@keys = $dict->structure_list();
  +&list_items(@keys);
   &verbose(($#keys + 1) . " found.");
   &verbose("Dumping structures.");
   &dump_list('S', %Structure);
  @@ -270,8 +215,8 @@
   EOHT
   
   &verbose("Analysing data cells: \\c");
  -&list_items('D', %Cell);
  -@keys = keys(%Cell);
  +@keys = $dict->cell_list();
  +&list_items(@keys);
   &verbose(($#keys + 1) . " found.");
   &verbose("Dumping data cells.");
   &dump_list('D', %Cell);
  @@ -300,8 +245,8 @@
   EOHT
   
   &verbose("Analysing constants: \\c");
  -&list_items('C', %Constant);
  -@keys = keys(%Constant);
  +@keys = $dict->constant_list();
  +&list_items(@keys);
   &verbose(($#keys + 1) . " found.");
   &verbose("Dumping constants.");
   &dump_list('C', %Constant);
  @@ -313,10 +258,10 @@
   # Dump a hash in alphabetical order.
   #
   sub dump_list {
  -    local ($prefix, %list) = @_;
  -    local (@keys) = sort {uc($a) cmp uc($b)} (keys(%list));
  -    my ($i) = 0;
  +    local($prefix, @keys) = @_;
  +    my($i) = 0;
   
  +    @keys = sort {uc($a) cmp uc($b)} (@keys);
       foreach $key (@keys) {
   	local (*dfh);
   	local ($previous, $next) = ("", "");
  @@ -335,62 +280,8 @@
       }
   }
   
  -#
  -# Turn any inline references to other structures or constants into links.
  -#
  -sub edit_inline {
  -    local ($wip, $rname) = @_;
  -    local ($ref);
  -
  -    #
  -    # This is an incredibly brute-force O(n^2) algorithm, but at least it's
  -    # clear and only run when updating the docco.
  -    #
  -    foreach $ref (keys(%Entity)) {
  -	my ($href) = $HREF{"$ref"};
  -	if ($ref ne $rname) {
  -	    $wip =~ s:([^-</])\b$ref\b:\1<a href="$href">$ref</a>:g;
  -	}
  -    }
  -    return $wip;
  -}
  -
  -#
  -# Read a record from the input stream.  Comments are trimmed, as is
  -# trailing whitespace.  Leading whitespace is trimmed IFF the argument to the
  -# functional evaluates as true.  A terminal slosh indicates that the next
  -# line should be read and the record re-processed.  All '\n' occurrences
  -# in the input are converted to newlines before being returned.
  -#
  -sub get_record {
  -    local ($trim_leading_ws, $continued) = (@_, 0);
  -    local ($trim_next) = 1;
  -    my ($line);
  -
  -    $line = <dfh> || return "";
  -    $DataLine++;
  -    chomp ($line);
  -    $line =~ s/#;.*//;
  -    $line =~ s/\s+$//;
  -    if ($trim_leading_ws) {
  -	$line =~ s/^\s+//;
  -    }
  -    if ($line =~ m:\\$:) {
  -	$line =~ s:\\n\s+\\$:\\n\\:;
  -	$line =~ s:\\$::;
  -	$trim_next = 0 if ($line =~ m:\\n$:);
  -	$line .= &get_record($trim_next, 1);
  -    }
  -    if ($line && (! $continued)) {
  -	$RecordNum++;
  -	$line =~ s:([^\\])\\n:\1\n:g;
  -	$line =~ s:\\\\:\\:g;
  -    }
  -    return ($line);
  -}
  -
   sub list_items {
  -    local ($prefix, %items) = @_;
  +    local(@items) = @_;
   
       if ($Layout == 0) {
   
  @@ -398,7 +289,7 @@
     <ol compact>
   EOHT
   
  -        foreach (sort {uc($a) cmp uc($b)} (keys(%items))) {
  +        foreach (sort {uc($a) cmp uc($b)} (@items)) {
   	    my ($uri) = $HREF{"$_"};
   
   	    print $ofh <<EOHT;
  @@ -454,12 +345,16 @@
   }
   
   sub dump_item {
  -    my ($ofh, $prefix, $key, $record, $previous, $next) = @_;
  -    my ($rtype, $iname, $idef, $isamp, $iref, $idesc) =
  -	split(m:\|:, $record);
  -    my ($uri) = $URL{"$iname"};
  -    my ($href) = $HREF{"$iname"};
  -    my ($edited);
  +    my($ofh, $prefix, $key, $record, $previous, $next) = @_;
  +    my($rtype) = $dict->category($key);
  +    my($iname) = $key;
  +    my($idef) = $dict->definition($key);
  +    my($isamp) = $dict->example($key);
  +    my($iref) = $dict->see_also($key);
  +    my($idesc) = $dict->description($key);
  +    my($uri) = $URL{$iname};
  +    my($href) = $HREF{$iname};
  +    my($edited);
   
       print $ofh <<EOHT if ($Layout == 0);
   <!doctype html public "-//W3C//DTD HTML 4.0 Transitional//EN"
  @@ -472,7 +367,7 @@
     <h1>Apache 1.3 API Documentation</h1>
   EOHT
   
  -    my($p) = $Prefix{$rtype};
  +    my($p) = $dict->category_name($rtype);
       if ($Layout == 0) {
       print $ofh <<EOHT;
     <h3>$p $iname</h3>
  @@ -483,8 +378,7 @@
     <h3><a name="$uri">$p $iname</a></h3>
   EOHT
       }
  -
  -    $edited = &edit_inline($idef, $iname);
  +    $edited = $dict->add_links($idef, $iname, %HREF);
       if (! $edited) {
   	$edited = "No prototype or definition available.";
   	&verbose("$0: no definition for $iname");
  @@ -512,7 +406,7 @@
   	    }
   	    print $ofh "<a name=\"$uri\"><pre>$edited</pre></a>\n";
   	}
  -        $edited = &edit_inline($isamp, $iname);
  +        $edited = $dict->add_links($isamp, $iname, %HREF);
   	if ((! $edited) && ($Layout < 2)) {
   	   $edited = "No examples available.";
   	   &verbose("$0: no examples for $iname");
  @@ -533,30 +427,31 @@
   EOHT
           }
   
  -	if (! $idesc) {
  -	    &verbose("$0: no detail file listed for $iname");
  +        $idesc = $dict->description($key);
  +	if ($idesc) {
  +            $idesc = $dict->add_links($idesc, $key, %HREF);
  +	    print $ofh <<EOHT if ($Layout < 2);
  +$idesc
  +EOHT
  +        }
  +        elsif (! ($idname = $dict->description_file($key))) {
  +	    &verbose("$0: no details listed for $iname");
   	    print $ofh <<EOHT if ($Layout < 2);
      <p>
      No documentation available.
      </p>
   EOHT
           }
  -	elsif (! -r $idesc) {
  -	    &verbose("$0: detail file does not exist: $idesc for $iname");
  -	    print $ofh <<EOHT;
  +	elsif (! -r $idname) {
  +            &verbose("$0: detail file does not exist: $idname for $iname");
  +                print $ofh <<EOHT;
      <p>
      Documentation file not accessible.
      </p>
   EOHT
           }
  -	else {
  -	    local ($drec);
  -
  -	    open DFILE, "<$idesc";
  -	    while ($drec = <DFILE>) {
  -		print $ofh &edit_inline($drec, $iname);
  -	    }
  -	    close (DFILE);
  +        else {
  +            print STDERR "Shouldn't get here!\n";
           }
           $edited = $iref;
           $edited =~ s/[\s,]//g;
  @@ -573,32 +468,13 @@
   #
   # Expand any aliased 'see-also' entries.
   #
  -            foreach (split(m:,:, $ref)) {
  -		if ($SeeAlso{$_}) {
  -		    $sees .= ",$SeeAlso{$_}";
  -		}
  -		else {
  -		    $sees .= ",$_";
  -		}
  -	    }
  -	    $ref = $sees;
  -	    foreach (sort {uc($a) cmp uc($b)} (split(m:,:, $ref))) {
  -		local ($item) = "<samp>$_</samp>";
  -		my ($uri) = $HREF{"$_"};
  -
  -		next if (($_ eq "") || ($_ eq $iname));
  -		if ($Entity{$_}) {
  -		    $item = "<a href=\"$uri\">$item</a>";
  -	        }
  -		else {
  -		    print STDERR "$0: undefined cross-reference: "
  -			. "$iname references undefined entity $_.\n";
  -		}
  -	        $ref_list .= $item . ",\n        ";
  -	    }
  -	    $ref_list =~ s:,\n        $:\n:;
  -	    print $ofh $ref_list;
  +            $sees = join(",\n        ", $dict->expanded_seealso($key));
  +            $edited = $dict->add_links($sees, $key,  %HREF);
  +            $edited =~ s:(">)([^<]+)(</a):$1<samp>$2</samp>$3:g;
  +#		    print STDERR "$0: undefined cross-reference: "
  +#			. "$iname references undefined entity $_.\n";
   	    print $ofh <<EOHT;
  +    <dd>$edited
       </dd>
      </dl>
   EOHT
  
  
  
  1.1                  httpd-docs-1.3/apidoc/APIdict.pm
  
  Index: APIdict.pm
  ===================================================================
  package APIdict;
  #
  # Package to deal with API documentation defined by entries in a flat
  # editable file.
  #
  # Edit history:
  #
  #  2000-09-15 Ken Coar
  #	Pull the relevant parts out of the mkapidict script so that
  #	other tools can use them (like a source scanner).
  #
  #	This is the first Perl 'module' I've written, so be gentle..
  #
  
  use POSIX;
  
  #
  # Public methods
  #
  
  #
  # Package constructor
  #
  #   $dict = new APIdict [('dictionary-file')];
  #
  sub new {
      my($self) = bless {}, shift;
      $self->init(@_);
      $self;
  }
  
  #
  # All other public methods appear in lexical order.
  #
  
  #
  # Turn any inline references to other entities into links.
  #
  sub add_links {
      my($self, $wip, $rname, %HREF) = @_;
      my($ref);
  
      #
      # This is an incredibly brute-force O(n^2) algorithm, but at least it's
      # clear and only run when updating the docco.
      #
      foreach $ref (keys(%Entity)) {
  	my($href) = $HREF{"$ref"};
  	if ($ref ne $rname) {
  	    $wip =~ s:([^-</]*)\b$ref\b:$1<a href="$href">$ref</a>:g;
  	}
      }
      return $wip;
  }
  
  sub category {
      my($self, $item) = @_;
      my($rtype);
  
      if (! $Entity{$item}) {
          return undef;
      }
      ($rtype) = split(m:\|:, $Entity{$item});
      return uc($rtype);
  }
  
  sub category_name {
      my($self, $prefix) = @_;
  
      return $Prefix{uc($prefix)};
  }
  
  sub cell_list {
      my($self, $item) = @_;
  
      return keys(%Cell);
  }
  
  #
  # Save the dictionary to the specified file, which may or may not
  # be the same as the original one read.
  #
  sub checkpoint {
      my($self) = @_;
  
      return &writefile($self, $DictFile);
  }
  
  sub constant_list {
      my($self, $item) = @_;
  
      return keys(%Constant);
  }
  
  #
  # Check to see if the specified name is in the dictionary.
  #
  sub defined {
      my($self, $item) = @_;
  
      return exists($Entity{$item});
  }
  
  #
  # Methods for defining new entries.
  #
  sub define_cell {
      my($self, @args) = @_;
  
      return &make_entry('C', @args);
  }
  
  sub define_constant {
      my($self, @args) = @_;
  
      return &make_entry('C', @args);
  }
  
  sub define_macro {
      my($self, @args) = @_;
  
      return &make_entry('M', @args);
  }
  
  sub define_routine {
      my($self, @args) = @_;
  
      return &make_entry('R', @args);
  }
  
  sub define_structure {
      my($self, @args) = @_;
  
      return &make_entry('S', @args);
  }
  
  sub define_xref {
      my($self, @args) = @_;
  
      return &make_entry('X', @args);
  }
  
  #
  # Methods for returning aspects of an entry.
  #
  
  sub definition {
      my($self, $item) = @_;
  
      return $Definition{$item};
  }
  
  sub description {
      my($self, $item) = @_;
  
      return $Description{$item};
  }
  
  sub description_file {
      my($self, $item) = @_;
  
      return $Description_file{$item};
  }
  
  #
  # Simply return the raw dictionary.
  #
  sub dictionary {
      return join("", @Dictionary);
  }
  
  sub entity_list {
      my($self, $item) = @_;
  
      return keys(%Entity);
  }
  
  sub example {
      my($self, $item) = @_;
  
      return $Example{$item};
  }
  
  #
  # Expand any xref references in a see-also list.
  #
  sub expanded_seealso {
      my($self, $item) = @_;
      my($work, $ref) = ("", $SeeAlso{$item});
      my(@in, @result);
      my(%items);
  
      @in = split(m:,:, $ref);
      foreach (@in) {
          push(@result, &references($_, $item));
      }
      #
      # Sort the results and weed out any duplicates.  Use the associative
      # array properties to do the work for us.
      #
      foreach (@result) {
          $items{"$_"} = 1;
      }
      delete($items{"$item"});
      @result = sort {uc($a) cmp uc($b)} (keys(%items));
      return @result;
  }
  
  #
  # Boolean checks for entity types.
  #
  sub is_cell {
      my($self, $item) = @_;
  
      return exists($Cell{$item});
  }
  
  sub is_constant {
      my($self, $item) = @_;
  
      return exists($Constant{$item});
  }
  
  sub is_macro {
      my($self, $item) = @_;
  
      return exists($Macro{$item});
  }
  
  sub is_routine {
      my($self, $item) = @_;
  
      return exists($Routine{$item});
  }
  
  sub is_structure {
      my($self, $item) = @_;
  
      return exists($Structure{$item});
  }
  
  sub is_xref {
      my($self, $item) = @_;
  
      return exists($Xref{$item});
  }
  
  #
  # Public methods for returning the lists of entries.
  #
  sub macro_list {
      my($self, $item) = @_;
  
      return keys(%Macro);
  }
  
  #
  # Create a unique item name.  This seems weird for a dictionary, but it
  # allows the module to be used to record the same information about other
  # types of things, such as error messages.  Of course, this doesn't actually
  # add the item to the dictionary; the caller has to do that separately.
  # That should probably be the next step aftet this, to avoid something
  # else being added with this name.
  #
  sub make_item {
      my($self, $text, $prefix) = @_;
      my($item, $counter, $length) = ("", 0, 16);
  
      $text =~ s:\W+::g;
      $item = $prefix . uc($text);
      do {
          $item = substr($item, 0, $length)
              . ($counter ? snprintf("%02d", $counter) : "");
          $counter++;
          $length = 14;
      } until (! &defined($item));
      return $item;
  }
      
  sub routine_list {
      my($self, $item) = @_;
  
      return keys(%Routine);
  }
  
  sub see_also {
      my($self, $item) = @_;
  
      return $SeeAlso{$item};
  }
  
  sub structure_list {
      my($self, $item) = @_;
  
      return keys(%Structure);
  }
  
  #
  # Read a dictionary file and load the arrays.
  #
  sub readfile {
      my($self, $dictfile) = @_;
      my($dir);
      my($rtype);
      local($DataLine) = 0;
      local($RecordNum) = 0;
      local($Continuing) = 0;
  
      $DictFile = $dictfile;
      #
      # If the dictionary file doesn't exist, assume we're creating a
      # new one and just saving the name for later writing/checkpointing.
      #
      if (! -r $dictfile) {
          return 1;
      }
      #
      # If the dictionary exists and we can't open it, though, that's
      # a problem.
      #
      open *DICTFILE, "<$dictfile"
          || die("Can't open dictionary file $dictfile");
  
      while (! eof(*DICTFILE)) {
          local(@field) = ("", "", "", "", "", "", "", "");
          local($rec);
  
          $rec = &get_record(1);
          next if (! $rec);
          chomp($rec);
          @field = split(m:\|:, $rec);
          $rec =~ s:\$\*:$field[1]:g;
          @field = split(m:\|:, $rec, -1);
          if ($#field != 5) {
              if ($#field < 5) {
                  $dir = "few";
              }
              else {
                  $dir = "many";
              }
              print STDERR "Too $dir fields (" . ($#field + 1)
                  . " instead of 6) for record $RecordNum at "
                  . "line $DataLine\n";
          }
          if ($field[0] !~ m:^[$prefix_chars]$:i) {
              print STDERR "Unrecognised record identifier /$field[0]/ "
                  . "for record ending on line $DataLine;\n"
                  . "\tmissing continuation character?\n";
              next;
          }
          if ($Entity{$field[1]}) {
              print STDERR "Item $field[1] redefined at line $DataLine.\n";
          }
          $Entity{$field[1]} = $rec;
          $rtype = uc(substr($field[0], 0, 1));
          if ($rtype eq 'R') {
              $Routine{$field[1]} = $rec;
          }
          elsif ($rtype eq 'M') {
              $Macro{$field[1]} = $rec;
          }
          elsif ($rtype eq 'S') {
              $Structure{$field[1]} = $rec;
          }
          elsif ($rtype eq 'C') {
              $Constant{$field[1]} = $rec;
          }
          elsif ($rtype eq 'D') {
              $Cell{$field[1]} = $rec;
          }
          elsif ($rtype eq 'X') {
              $Xref{$field[1]} = $field[2];
          }
          if ($rtype =~ /M|R/) {
              $Callable{$field[1]} = $rec;
          }
          $Definition{$field[1]} = $field[2];
          $rDefinition{$field[2]} = $field[1];
          $Example{$field[1]} = $field[3];
          if ($rtype ne 'X') {
              $SeeAlso{$field[1]} = $field[4];
              $Description{$field[1]} = $field[5];
              $Description_file{$field[1]} = "";
              if ($field[5] =~ m:^<(.*):) {
                  my($fname) = $1;
                  $Description_file{$field[1]} = $1;
                  $fname =~ s:\$\*:$field[1]:g;
                  if (-r $fname) {
                      open *DFILE, "<$fname";
                      $Description{$field[1]} = join("", <DFILE>);
                      close DFILE;
                  }
                  else {
                      $Description{$field[1]} = "";
                  }
              }
          }
      }
  }
  
  #
  # Return statistics about the dictionary.  The return value is an
  # associative array with the following keys:
  #
  #   "entries"
  #   "routines"
  #   "cells"
  #   "lines"
  #   "macros"
  #   "structures"
  #   "constants"
  #
  sub statistics {
      my(@counter, %stats) = ();
  
      @counter = keys(%Entity);
      $stats{"entries"} = $#counter + 1;
      @counter = keys(%Macro);
      $stats{"macros"} = $#counter + 1;
      @counter = keys(%Constant);
      $stats{"constants"} = $#counter + 1;
      @counter = keys(%Routine);
      $stats{"routines"} = $#counter + 1;
      @counter = keys(%Cell);
      $stats{"cells"} = $#counter + 1;
      @counter = keys(%Structure);
      $stats{"structures"} = $#counter + 1;
      $stats{"lines"} = $#Dictionary + 1;
      return %stats;
  }
  
  #
  # Make a backup of the specified output file (if it exists), and
  # write our current dictionary into the original file.
  #
  sub writefile {
      my($self, $outfile) = @_;
  
      if (! $dirty) {
  	return 1;
      }
      $outfile = $DictFile if (! $outfile);
      &backup($outfile);
      open *NEWDICT, ">${outfile}"
          || die("Can't open new dictionary file");
      foreach (@Dictionary) {
          print NEWDICT $_;
      }
      print NEWDICT "#;\n#; Definitions added by APIdict at "
          . strftime("%Y-%m-%d %H:%M", localtime()) . "\n#;\n";
      foreach $entry (sort(@uncommitted)) {
          my($rtype, $item) = split(m:=:, $entry);
          my($record);
  
          $record = "$rtype|$item\\\n";
          $record .= "    |" . $Definition{$item} . "\\\n";
          $record .= "    |" . $Example{$item} . "\\\n";
          $record .= "    |" . $SeeAlso{$item} . "\\\n";
          $record .= "    |"
              . ($Description_file{$item} || $Description{$item})
              . "\n";
          print NEWDICT $record;
          push(@Dictionary, $record);
      }
      close *NEWDICT;
      $dirty = 0;
      @uncommitted = ();
      return 0;
  }
  
  sub xref_list {
      my($self, $item) = @_;
  
      return keys(%Xref);
  }
  
  #
  # Private methods
  #
  
  #
  # Make a backup of the specified file by renaming it to *.1.  If
  # a *.1 file exists, rename *that* to *.2 and so on, until we can
  # move the original one to *.1.
  #
  sub backup {
      my($filename) = @_;
      my($index, $newindex, $basename) = ("", 1, $filename);
  
      $filename =~ /(.*)\.([0-9]+$)/;
      ($basename, $index) = ($1, $2);
      if ($index) {
          $newindex = $index + 1;
      }
      else {
          $basename = $filename;
      }
      if (-e "$basename.$newindex") {
          &backup("$basename.$newindex");
      }
      rename($filename, "$basename.$newindex");
  }
  
  sub err_is_defined {
      my($item) = @_;
  
      print STDERR "Item $item is already defined!\n";
      return 0;
  }
  
  #
  # Initialiser method.  Read in the specified file (if one
  # was mentioned) and create the associative arrays and package-private
  # data cells.
  #
  sub init {
      my($self, @args) = @_;
  
      $dirty = 0;                 # Whether the dict has changed since read
      @uncommitted = ();          # List of items added
      @Dictionary = ();           # Raw text read from the dictionary file
      $DictFile = "";             # Name of dictionary file (for checkpoints)
  
      %Prefix = ('R' => 'Routine',
  	       'M' => 'Macro',
  	       'C' => 'Constant',
  	       'S' => 'Structure',
  	       'X' => 'Cross-reference',
  	       'D' => 'Global Data Cell');
      $prefix_chars = join("", keys(%Prefix));
  
      %Entity = ();               # Array of Booleans for name-is-defined tests
      %Routine = ();              # Array of routine names
      %Macro = ();                # Array of macro names
      %Callable = ();             # Array of active items (routines + macros)
      %Constant = ();             # Array of constant names
      %Structure = ();            # Array of structure names
      %Cell = ();                 # Array of names of global data cells
      %Xref = ();                 # Array of related-names lists
  
      %Example = ();              # Array of examples for entities
      %Definition = ();           # Array of item definitions
      %rDefinition = ();          # Reverse-map definition to item name
      %Description = ();          # Item descriptions
      %Description_file = ();     # Names of description files
      %SeeAlso = ();              # Array of references for items
  
      if (@args) {
  	return &readfile(@_);
      }
      return 1;
  }
  
  #
  # Private method to add an entry to the dictionary.
  #
  sub make_entry {
      my($rtype, $item, $def, $example, $xref, $desc) = @_;
  
      if ($Entity{$item}) {
          return &err_is_defined($item);
      }
      $item = &sanitise($item);
      $def = &sanitise($item, $def);
      $example = &sanitise($item, $example);
      $xref = &sanitise($item, $xref);
      $desc = &sanitise($item, $desc);
      $Definition{$item} = $def;
      $rDefinition{$def} = $item;
      $Example{$item} = $example;
      $SeeAlso{$item} = $xref;
      $Description{$item} = "";
      if ($desc =~ /^<(.*)/) {
          $Description_file{$item} = $desc;
          $dfile = $1;
          if (-r $dfile) {
              if (open *DFILE, $desc) {
                  my(@lines) = <DFILE>;
                  close DFILE;
                  $Description{$item} = join("", @lines);
              }
          }
      }
      else {
          $Description{$item} = $desc;
          $Description_file{$item} = "";
      }
      $desc = ($Description_file{$item}
               ? $Description_file{$item} : $Description{$item});
      $rec = "$rtype|$item|$def|$example|$xref|desc";
      if ($rtype eq 'R') {
          $Routine{$item} = $rec;
      }
      elsif ($rtype eq 'M') {
          $Macro{$item} = $rec;
      }
      elsif ($rtype eq 'C') {
          $Constant{$item} = $rec;
      }
      elsif ($rtype eq 'S') {
          $Structure{$item} = $rec;
      }
      elsif ($rtype eq 'X') {
          $Xref{$item} = $rec;
      }
      elsif ($rtype eq 'D') {
          $Cell{$item} = $rec;
      }
      $Entity{$item} = 1;
      push(@uncommitted, "$rtype=$item");
      $dirty++;
  }
  
  #
  # Check the argument to see if it can be expanded to any additional
  # cross-references.
  #
  sub references {
      my($ref) = @_;
      my($key, @list, @result) = ();
  
      $key = $Xref{$ref};
      if (! $key) {
          return $ref;
      }
      @list = split(m:,:, $key);
      foreach (@list) {
          push(@result, &references($_));
      }
      return @result;
  }
  
  #
  # Do any necessary substitutions, such as replacing '$*' with the item name
  # and '|' with '&#124;'.
  #
  sub sanitise {
      local($item, $_) = @_;
  
      if (! defined($_)) {
          $_ = $item;
      }
      else {
          s:$item:\$\*:g;
      }
      s:\|:\&#124;:g;
      return $_;
  }
  
  #
  # Read a record from the input stream.  Comments are trimmed, as is
  # trailing whitespace.  Leading whitespace is trimmed IFF the argument to the
  # functional evaluates as true.  A terminal slosh indicates that the next
  # line should be read and the record re-processed.  All '\n' occurrences
  # in the input are converted to newlines before being returned.
  #
  sub get_record {
      local ($trim_leading_ws, $continued) = (@_, 0);
      local ($trim_next) = 1;
      my ($line);
  
      $line = <DICTFILE> || return "";
      push(@Dictionary, $line);
      $DataLine++;
      chomp ($line);
      $line =~ s/#;.*//;
      $line =~ s/\s+$//;
      if ($trim_leading_ws) {
  	$line =~ s/^\s+//;
      }
      if ($line =~ m:\\$:) {
  	$line =~ s:\\n\s+\\$:\\n\\:;
  	$line =~ s:\\$::;
  	$trim_next = 0 if ($line =~ m:\\n$:);
  	$line .= &get_record($trim_next, 1);
      }
      if ($line && (! $continued)) {
  	$RecordNum++;
  	$line =~ s:([^\\])\\n:$1\n:g;
  	$line =~ s:\\\\:\\:g;
      }
      return ($line);
  }
  
  sub verbose {
      my(@lines) = @_;
      my($suffix);
  
      if ($Verbose) {
  	foreach (@lines) {
  	    if (m:\\c$:) {
  		$suffix = "";
  	      s:\\c$::;
  	    }
  	    else {
  		$suffix = "\n";
  	    }
  	    print STDERR $_, $suffix;
  	}
      }
      return 1;
  }
  
  sub debug {
      my(@lines) = @_;
      my($suffix);
  
      if ($Debug) {
  	foreach (@lines) {
  	    if (m:\\c$:) {
  		$suffix = "";
  	      s:\\c$::;
  	    }
  	    else {
  		$suffix = "\n";
  	    }
  	    print STDERR $_, $suffix;
  	}
      }
      return 1;
  }
  
  #
  # {Sigh}  Modules must have values, and this is ours.
  #
  1;
  
  
  
  1.1                  httpd-docs-1.3/apidoc/dict-SECURITY_HOLE_PASS_AUTHORIZATION.html
  
  Index: dict-SECURITY_HOLE_PASS_AUTHORIZATION.html
  ===================================================================
  <p>
  When user authentication is required to obtain access to a document,
  the user credentials (username and password) are available to the
  server.  Ordinarily Apache only makes the username available to
  <code>mod_include</code> and CGI scripts, keeping the password
  secret.  It can be configured to make the complete credential
  details available (in the <code>HTTP_AUTHORIZATION</code> or
  <code>HTTP_PROXY_AUTHORIZATION</code> environment variables),
  but only by completely rebuilding the server with this
  compile-time definition added (as shown in the example).
  </p>
  <p>
  <b>Warning:</b> Enabling this feature is considered a security
  risk, as scripts and documents can capture all aspects of the
  user credentials.  For example, your configuration may include
  an authentication database that is accessible only by the server,
  and not directly available to users.  With this feature enabled,
  any script that is flagged as needing authentication checks against
  that database, even a user script, will be able to capture the
  credentials.  In the case of <code>Basic</code> authentication,
  the password is available in cleartext.
  </p>
  
  
  
  1.1                  httpd-docs-1.3/apidoc/findapi
  
  Index: findapi
  ===================================================================
  #!/usr/local/bin/perl -w
  #
  # Copyright 2000 by Ken Coar.
  # Redistribution permitted in original or modified form provided
  # the copyright holder is attributed.
  #
  # This script uses the API dictionary module and the list of files
  # on the command line to update the dictionary from the current
  # sources.
  #
  # Use:
  #
  #   find ~/apache-1.3 -type f -name \*.h |xargs ./findapi
  #
  # It's currently pretty inefficient and very poorly documented, but
  # it was a rush job.
  #
  # History:
  #
  # 2000-09-15 Ken Coar
  #   Original version.
  #
  use APIdict;
  
  $dict = new APIdict;
  
  $dict->readfile("api.list");
  
  $collecting = 0;
  $last_file = "";
  
  while (<>) {
      if ($ARGV ne $last_file) {
  	$last_file = $ARGV;
      }
      chomp;
      if (! $collecting) {
  	if ($_ =~ m:^\s*(extern)?\s*API_[A-Z]+\s*(\([^)]*\)\s*)?:) {
  	    $collecting++;
  	    $file = $ARGV;
  	    $call = $_;
  	    $lineno = $.;
  	}
      }
      else {
          s:^\s+::;
  	$call .= " $_";
      }
      if ($_ =~ m:;:) {
  	$collecting = 0;
      }
      if ((! $collecting) && $call) {
  	while ($call =~ m:"[^"]*[^\\]" ":) {
  	    $call =~ s:("[^"]*[^\\])"\s+":$1:g;
          }
  	$call =~ s:<:\&lt;:g;
  	$call =~ s:>:\&gt;:g;
          analyse($call, $file, $lineno);
  	$call = "";
      }
  }
  
  $dict->checkpoint();
  
  sub analyse {
      my($call, $file, $lineno) = @_;
  
      $_ = $call;
      #
      # Throw away any leading or trailing whitespace, comments, et cetera.
      #
      s/^\s*([^;]+;).*/$1/;
      s:/\*.*?\*/::g;
      s:([^(]+)\s+\(:$1\(:g;
      #
      # Do some cleanup, such as removing extraneous whitespace and adding
      # it where it's missing.
      #
      s/\s{2,}/ /g;
      s/,(\S)/, $1/g;
      s/\)\s+;/\);/;
      #
      # Remove the export prefix and any 'extern' keyword for variable
      # declarations.
      #
      s/^extern\s+//;
      s/^API[_A-Z0-9]+\s*\(([^)]+\*)\)\s*/$1/;
      s/^API[_A-Z0-9]+\s*\(([^)]+)\)/$1/;
      s/^API[_A-Z0-9]+\s*//;
      s/^extern\s+//;
      #
      # Join up any pointer marks with the pointer identifier.  We need to
      # do this now rather than earlier because of the removal of the
      # API prefix, which may have introduced the space.
      #
      s/ \* / \*/g;
      $definition = $_;
      #
      # Okey, we've obtained the definition.  Now we need to take it to the
      # next level and figure out the name and type of the thing being
      # defined.
      #
      if (m:\);:) {               # Trailing routine closure?
          $itype = 'R';
      }
      else {
          $itype = 'D';
      }
      #
      # Extract just the routine name from definitions.
      #
      s/[^(]*\s+\**([a-zA-Z][a-zA-Z0-9_]+)\(.*/$1/;
      s/\([^)]+\)\s*;/;/;
      /\**(\S+);/;
      $_ = $1;
      s/\[.+?\]//g;
      $item = $_;
      if ($_ && (! $dict->defined($item))) {
          print "Adding " . (($itype eq 'R') ? "routine" : "cell") . " $_\n";
  	if ($itype eq 'R') {
  	    $dict->define_routine($item, $definition, "", "", "");
  	}
  	else {
  	    $dict->define_cell($item, $definition, "", "", "");
  	}
      }
  }
  
  
  

Mime
View raw message