Eine aufbereitete Darstellung der Quelle

 
     
 
 
Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 

Benutzer

Quelle  Makefile.in

  Sprache: C
 

SHELL = /bin/sh
SRCS = alldig.c allprint.c argv.c argv_split.c attr_clnt.c attr_print0.c \
 attr_print64.c attr_print_plain.c attr_scan0.c attr_scan64.c \
 attr_scan_plain.c auto_clnt.c base64_code.c basename.c binhash.c \
 chroot_uid.c cidr_match.c clean_env.c close_on_exec.c concatenate.c \
 ctable.c dict.c dict_alloc.c dict_cdb.c dict_cidr.c dict_db.c \
 dict_dbm.c dict_debug.c dict_env.c dict_ht.c dict_lmdb.c dict_ni.c dict_nis.c \
 dict_nisplus.c dict_open.c dict_pcre.c dict_regexp.c dict_sdbm.c \
 dict_static.c dict_tcp.c dict_unix.c dir_forest.c doze.c dummy_read.c \
 dummy_write.c duplex_pipe.c environ.c events.c exec_command.c \
 fifo_listen.c fifo_trigger.c file_limit.c find_inet.c fsspace.c \
 fullname.c get_domainname.c get_hostname.c hex_code.c hex_quote.c \
 host_port.c htable.c inet_addr_host.c inet_addr_list.c \
 inet_addr_local.c inet_connect.c inet_listen.c inet_proto.c \
 inet_trigger.c line_wrap.c lowercase.c lstat_as.c mac_expand.c \
 mac_parse.c make_dirs.c mask_addr.c match_list.c match_ops.c msg.c \
 msg_output.c msg_syslog.c msg_vstream.c mvect.c myaddrinfo.c myflock.c \
 mymalloc.c myrand.c mystrtok.c name_code.c name_mask.c netstring.c \
 neuter.c non_blocking.c nvtable.c open_as.c open_limit.c open_lock.c \
 peekfd.c posix_signals.c printable.c rand_sleep.c \
 readlline.c ring.c safe_getenv.c safe_open.c \
 sane_accept.c sane_connect.c sane_link.c sane_rename.c \
 sane_socketpair.c sane_time.c scan_dir.c set_eugid.c set_ugid.c \
 load_lib.c \
 sigdelay.c skipblanks.c sock_addr.c spawn_command.c split_at.c \
 split_nameval.c stat_as.c strcasecmp.c stream_connect.c \
 stream_listen.c stream_recv_fd.c stream_send_fd.c stream_trigger.c \
 sys_compat.c timed_connect.c timed_read.c timed_wait.c timed_write.c \
 translit.c trimblanks.c unescape.c unix_connect.c unix_listen.c \
 unix_recv_fd.c unix_send_fd.c unix_trigger.c unsafe.c uppercase.c \
 username.c valid_hostname.c vbuf.c vbuf_print.c vstream.c \
 vstream_popen.c vstring.c vstring_vstream.c watchdog.c \
 write_buf.c sane_basename.c format_tv.c allspace.c \
 allascii.c load_file.c killme_after.c vstream_tweak.c \
 pass_trigger.c edit_file.c inet_windowsize.c \
 unix_pass_fd_fix.c dict_cache.c valid_utf8_string.c dict_thash.c \
 ip_match.c nbbio.c base32_code.c dict_test.c \
 dict_fail.c msg_rate_delay.c dict_surrogate.c warn_stat.c \
 dict_sockmap.c line_number.c recv_pass_attr.c pass_accept.c \
 poll_fd.c timecmp.c slmdb.c dict_pipe.c dict_random.c \
 valid_utf8_hostname.c midna_domain.c argv_splitq.c balpar.c dict_union.c \
 extpar.c dict_inline.c casefold.c dict_utf8.c strcasecmp_utf8.c \
 split_qnameval.c argv_attr_print.c argv_attr_scan.c dict_file.c \
 msg_logger.c logwriter.c unix_dgram_connect.c unix_dgram_listen.c \
 byte_mask.c known_tcp_ports.c argv_split_at.c dict_stream.c \
 sane_strtol.c hash_fnv.c ldseed.c mkmap_cdb.c mkmap_db.c mkmap_dbm.c \
 mkmap_fail.c mkmap_lmdb.c mkmap_open.c mkmap_sdbm.c inet_prefix_top.c \
 inet_addr_sizes.c quote_for_json.c mystrerror.c \
 sane_sockaddr_to_hostaddr.c normalize_ws.c valid_uri_scheme.c \
 clean_ascii_cntrl_space.c normalize_v4mapped_addr.c ossl_digest.c \
 mac_midna.c wrap_stat.c
OBJS = alldig.o allprint.o argv.o argv_split.o attr_clnt.o attr_print0.o \
 attr_print64.o attr_print_plain.o attr_scan0.o attr_scan64.o \
 attr_scan_plain.o auto_clnt.o base64_code.o basename.o binhash.o \
 chroot_uid.o cidr_match.o clean_env.o close_on_exec.o concatenate.o \
 ctable.o dict.o dict_alloc.o dict_cidr.o dict_db.o \
 dict_dbm.o dict_debug.o dict_env.o dict_ht.o dict_ni.o dict_nis.o \
 dict_nisplus.o dict_open.o dict_regexp.o \
 dict_static.o dict_tcp.o dict_unix.o dir_forest.o doze.o dummy_read.o \
 dummy_write.o duplex_pipe.o environ.o events.o exec_command.o \
 fifo_listen.o fifo_trigger.o file_limit.o find_inet.o fsspace.o \
 fullname.o get_domainname.o get_hostname.o hex_code.o hex_quote.o \
 host_port.o htable.o inet_addr_host.o inet_addr_list.o \
 inet_addr_local.o inet_connect.o inet_listen.o inet_proto.o \
 inet_trigger.o line_wrap.o lowercase.o lstat_as.o mac_expand.o \
 load_lib.o \
 mac_parse.o make_dirs.o mask_addr.o match_list.o match_ops.o msg.o \
 msg_output.o msg_syslog.o msg_vstream.o mvect.o myaddrinfo.o myflock.o \
 mymalloc.o myrand.o mystrtok.o name_code.o name_mask.o netstring.o \
 neuter.o non_blocking.o nvtable.o open_as.o open_limit.o open_lock.o \
 peekfd.o posix_signals.o printable.o rand_sleep.o \
 readlline.o ring.o safe_getenv.o safe_open.o \
 sane_accept.o sane_connect.o sane_link.o sane_rename.o \
 sane_socketpair.o sane_time.o scan_dir.o set_eugid.o set_ugid.o \
 sigdelay.o skipblanks.o sock_addr.o spawn_command.o split_at.o \
 split_nameval.o stat_as.o $(STRCASE) stream_connect.o \
 stream_listen.o stream_recv_fd.o stream_send_fd.o stream_trigger.o \
 sys_compat.o timed_connect.o timed_read.o timed_wait.o timed_write.o \
 translit.o trimblanks.o unescape.o unix_connect.o unix_listen.o \
 unix_recv_fd.o unix_send_fd.o unix_trigger.o unsafe.o uppercase.o \
 username.o valid_hostname.o vbuf.o vbuf_print.o vstream.o \
 vstream_popen.o vstring.o vstring_vstream.o watchdog.o \
 write_buf.o sane_basename.o format_tv.o allspace.o \
 allascii.o load_file.o killme_after.o vstream_tweak.o \
 pass_trigger.o edit_file.o inet_windowsize.o \
 unix_pass_fd_fix.o dict_cache.o valid_utf8_string.o dict_thash.o \
 ip_match.o nbbio.o base32_code.o dict_test.o \
 dict_fail.o msg_rate_delay.o dict_surrogate.o warn_stat.o \
 dict_sockmap.o line_number.o recv_pass_attr.o pass_accept.o \
 poll_fd.o timecmp.o $(NON_PLUGIN_MAP_OBJ) dict_pipe.o dict_random.o \
 valid_utf8_hostname.o midna_domain.o argv_splitq.o balpar.o dict_union.o \
 extpar.o dict_inline.o casefold.o dict_utf8.o strcasecmp_utf8.o \
 split_qnameval.o argv_attr_print.o argv_attr_scan.o dict_file.o \
 msg_logger.o logwriter.o unix_dgram_connect.o unix_dgram_listen.o \
 byte_mask.o known_tcp_ports.o argv_split_at.o dict_stream.o \
 sane_strtol.o hash_fnv.o ldseed.o mkmap_db.o mkmap_dbm.o \
 mkmap_fail.o mkmap_open.o inet_prefix_top.o inet_addr_sizes.o \
 quote_for_json.o mystrerror.o sane_sockaddr_to_hostaddr.o \
 normalize_ws.o valid_uri_scheme.o clean_ascii_cntrl_space.o \
 normalize_v4mapped_addr.o ossl_digest.o mac_midna.o wrap_stat.o
MAP_OBJ is for maps that may be dynamically loaded with dynamicmaps.cf.
When hard-linking these, makedefs sets NON_PLUGIN_MAP_OBJ=$(MAP_OBJ),
otherwise it sets the PLUGIN_* macros.
MAP_OBJ = dict_pcre.o dict_cdb.o dict_lmdb.o dict_sdbm.o slmdb.o \
 mkmap_cdb.o mkmap_lmdb.o mkmap_sdbm.o 
HDRS = argv.h attr.h attr_clnt.h auto_clnt.h base64_code.h binhash.h \
 chroot_uid.h cidr_match.h clean_env.h connect.h ctable.h dict.h \
 dict_cdb.h dict_cidr.h dict_db.h dict_dbm.h dict_debug.h dict_env.h \
 dict_ht.h \
 dict_lmdb.h dict_ni.h dict_nis.h dict_nisplus.h dict_pcre.h dict_regexp.h \
 dict_sdbm.h dict_static.h dict_tcp.h dict_unix.h dir_forest.h \
 events.h exec_command.h find_inet.h fsspace.h fullname.h \
 get_domainname.h get_hostname.h hex_code.h hex_quote.h host_port.h \
 htable.h inet_addr_host.h inet_addr_list.h inet_addr_local.h \
 inet_proto.h iostuff.h line_wrap.h listen.h lstat_as.h mac_expand.h \
 mac_parse.h make_dirs.h mask_addr.h match_list.h msg.h \
 msg_output.h msg_syslog.h msg_vstream.h mvect.h myaddrinfo.h myflock.h \
 mymalloc.h myrand.h name_code.h name_mask.h netstring.h nvtable.h \
 open_as.h open_lock.h posix_signals.h readlline.h ring.h \
 safe.h safe_open.h sane_accept.h sane_connect.h sane_fsops.h \
 load_lib.h \
 sane_socketpair.h sane_time.h scan_dir.h set_eugid.h set_ugid.h \
 sigdelay.h sock_addr.h spawn_command.h split_at.h stat_as.h \
 stringops.h sys_defs.h timed_connect.h timed_wait.h trigger.h \
 username.h valid_hostname.h vbuf.h vbuf_print.h vstream.h vstring.h \
 vstring_vstream.h watchdog.h format_tv.h load_file.h killme_after.h \
 edit_file.h dict_cache.h dict_thash.h ip_match.h nbbio.h base32_code.h \
 dict_fail.h warn_stat.h dict_sockmap.h line_number.h timecmp.h \
 slmdb.h compat_va_copy.h dict_pipe.h dict_random.h parse_utf8_char.h \
 valid_utf8_hostname.h midna_domain.h dict_union.h dict_inline.h \
 check_arg.h argv_attr.h msg_logger.h logwriter.h byte_mask.h \
 known_tcp_ports.h sane_strtol.h hash_fnv.h ldseed.h mkmap.h \
 inet_prefix_top.h inet_addr_sizes.h valid_uri_scheme.h \
 clean_ascii_cntrl_space.h normalize_v4mapped_addr.h ossl_digest.h \
 mac_midna.h wrap_stat.h
TESTSRC = fifo_open.c fifo_rdwr_bug.c fifo_rdonly_bug.c select_bug.c \
 stream_test.c dup2_pass_on_exec.c
DEFS = -I. -D$(SYSTYPE)
CFLAGS = $(DEBUG) $(OPT) $(DEFS)
FILES = Makefile $(SRCS) $(HDRS)
INCL =
LIB = lib$(LIB_PREFIX)util$(LIB_SUFFIX)
TESTPROG= dict_open dup2_pass_on_exec events exec_command fifo_open \
 fifo_rdonly_bug fifo_rdwr_bug fifo_trigger fsspace fullname \
 inet_addr_host inet_addr_local mac_parse make_dirs msg_syslog \
 mystrtok sigdelay translit valid_hostname vstream_popen \
 vstring vstring_vstream doze select_bug stream_test mac_expand \
 watchdog unescape hex_quote name_mask rand_sleep sane_time ctable \
 inet_addr_list attr_print64 attr_scan64 base64_code attr_print0 \
 attr_scan0 host_port attr_scan_plain attr_print_plain htable \
 unix_recv_fd unix_send_fd stream_recv_fd stream_send_fd hex_code \
 myaddrinfo myaddrinfo4 inet_proto sane_basename format_tv \
 valid_utf8_string ip_match base32_code msg_rate_delay netstring \
 vstream timecmp dict_cache midna_domain casefold strcasecmp_utf8 \
 vbuf_print split_qnameval vstream msg_logger byte_mask \
 known_tcp_ports dict_stream find_inet binhash hash_fnv_test argv \
 clean_env inet_prefix_top printable readlline quote_for_json \
 normalize_ws valid_uri_scheme clean_ascii_cntrl_space \
 normalize_v4mapped_addr_test ossl_digest_test dict_pipe_test \
 dict_union_test
PLUGIN_MAP_SO = $(LIB_PREFIX)pcre$(LIB_SUFFIX) $(LIB_PREFIX)lmdb$(LIB_SUFFIX) \
 $(LIB_PREFIX)cdb$(LIB_SUFFIX) $(LIB_PREFIX)sdbm$(LIB_SUFFIX)
HTABLE_FIX = NORANDOMIZE=1
LIB_DIR = ../../lib
INC_DIR = ../../include
TESTLIB = $(LIB_DIR)/libtesting.a

.c.o:; $(CC) $(SHLIB_CFLAGS) $(CFLAGS) -c $*.c

all: $(LIB) $(PLUGIN_MAP_SO_MAKE) $(PLUGIN_MAP_OBJ)

$(OBJS) $(PLUGIN_MAP_OBJ): ../../conf/makedefs.out

Makefile: Makefile.in
 cat ../../conf/makedefs.out $? >$@

test: $(TESTPROG)

$(LIB): $(OBJS)
 $(AR) $(ARFL) $(LIB) $?
 $(RANLIB) $(LIB)
 $(SHLIB_LD) $(SHLIB_RPATH) -o $(LIB) $(OBJS) $(SHLIB_SYSLIBS)

$(LIB_DIR)/$(LIB): $(LIB)
 cp $(LIB) $(LIB_DIR)
 $(RANLIB) $(LIB_DIR)/$(LIB)

plugin_map_so_make: $(PLUGIN_MAP_SO)

$(LIB_PREFIX)pcre$(LIB_SUFFIX): dict_pcre.o
 $(PLUGIN_LD) $(SHLIB_RPATH) -o $@ dict_pcre.o $(AUXLIBS_PCRE)

$(LIB_PREFIX)cdb$(LIB_SUFFIX): mkmap_cdb.o dict_cdb.o
 $(PLUGIN_LD) $(SHLIB_RPATH) -o $@ mkmap_cdb.o \
     dict_cdb.o $(AUXLIBS_CDB)

$(LIB_PREFIX)lmdb$(LIB_SUFFIX): mkmap_lmdb.o dict_lmdb.o slmdb.o
 $(PLUGIN_LD) $(SHLIB_RPATH) -o $@ mkmap_lmdb.o dict_lmdb.o \
     slmdb.o $(AUXLIBS_LMDB)

$(LIB_PREFIX)sdbm$(LIB_SUFFIX): mkmap_sdbm.o dict_sdbm.o
 $(PLUGIN_LD) $(SHLIB_RPATH) -o $@ mkmap_sdbm.o \
     dict_sdbm.o $(AUXLIBS_SDBM)

update: $(LIB_DIR)/$(LIB) $(HDRS) $(PLUGIN_MAP_SO_UPDATE) \
 $(PLUGIN_MAP_OBJ_UPDATE)
 -for i in $(HDRS); \
 do \
   cmp -s $$i $(INC_DIR)/$$i 2>/dev/null || cp $$i $(INC_DIR); \
 done
 cd $(INC_DIR); chmod 644 $(HDRS)

plugin_map_so_update: $(PLUGIN_MAP_SO)
 -for i in $(PLUGIN_MAP_SO); \
 do \
   for type in $(DEFINED_MAP_TYPES); do \
       case $$i in $(LIB_PREFIX)$$type$(LIB_SUFFIX)) \
    cmp -s $$i $(LIB_DIR)/$$i 2>/dev/null || cp $$i $(LIB_DIR); \
    continue 2;; \
       esac; \
   done; \
   rm -f $(LIB_DIR)/$$i; \
 done

plugin_map_obj_update: $(LIB_MAP_OBJ)
 -for i in $(LIB_MAP_OBJ); \
 do \
   cmp -s $$i $(LIB_DIR)/$$i 2>/dev/null || cp $$i $(LIB_DIR); \
 done

clean:
 rm -f *.o $(LIB) *core $(TESTPROG) junk $(MAKES) *.tmp testdb.db

tidy: clean

dup2_pass_on_exec: dup2_pass_on_exec.c
 $(CC) $(CFLAGS) -o $@ $@.c $(SYSLIBS)

vstring: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

msg_logger: msg_logger.c $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

msg_syslog: msg_syslog.c $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

vstring_vstream: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

valid_hostname: valid_hostname.c $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

events: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

dict_open: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

fullname: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

inet_addr_local: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

inet_addr_host: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

fifo_open: fifo_open.c
 $(CC) $(CFLAGS) -o $@ $@.c $(SYSLIBS)

sigdelay: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

mystrtok: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

fifo_rdwr_bug: fifo_rdwr_bug.c $(LIB)
 $(CC) $(CFLAGS)  -o $@ $@.c $(LIB) $(SYSLIBS)

fifo_rdonly_bug: fifo_rdonly_bug.c $(LIB)
 $(CC) $(CFLAGS)  -o $@ $@.c $(LIB) $(SYSLIBS)

select_bug: select_bug.c $(LIB)
 $(CC) $(CFLAGS)  -o $@ $@.c $(LIB) $(SYSLIBS)

translit: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

fsspace: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

exec_command: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

make_dirs: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

mac_parse: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

vstream_popen: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

fifo_trigger: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

doze: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

mac_expand: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

watchdog: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

unescape: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

printable: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

readlline: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

hex_quote: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

name_mask: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

byte_mask: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

rand_sleep: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

sane_time: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

ctable: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

inet_addr_list: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

attr_print64: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

attr_scan64: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

base64_code: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

attr_print0: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

attr_scan0: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

host_port: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

attr_scan_plain: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

attr_print_plain: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

htable: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

binhash: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

hash_fnv_test: $(LIB) update
 $(CC) $(CFLAGS) -o $@ $@.c $(LIB) $(SYSLIBS)

unix_recv_fd:  $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

unix_send_fd:  $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

stream_recv_fd:  $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

stream_send_fd:  $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

hex_code: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

myaddrinfo: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

myaddrinfo4: $(LIB)
 mv myaddrinfo.o junk
 $(CC) $(CFLAGS) -DTEST -DEMULATE_IPV4_ADDRINFO -o $@ myaddrinfo.c $(LIB) $(SYSLIBS)
 mv junk myaddrinfo.o

inet_proto: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

sane_basename: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

find_inet: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

clean_env: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

stream_test: stream_test.c $(LIB)
 $(CC) $(CFLAGS)  -o $@ $@.c $(LIB) $(SYSLIBS)

gcctest: gccw.c gccw.ref
 rm -f gccw.o
 make gccw.o 2>&1 | sed "s/\`/'/g; s/return-/return /" | sort >gccw.tmp
 diff gccw.ref gccw.tmp
 rm -f gccw.o gccw.tmp

format_tv: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

valid_utf8_string: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

ip_match: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

base32_code: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

msg_rate_delay: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

netstring: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

vstream: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

timecmp: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

dict_cache: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

midna_domain: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

casefold: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

strcasecmp_utf8: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

vbuf_print: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

split_qnameval: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

known_tcp_ports: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

dict_stream: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

argv: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

inet_prefix_top: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

quote_for_json: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

normalize_ws: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

valid_uri_scheme: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

clean_ascii_cntrl_space: $(LIB)
 mv $@.o junk
 $(CC) $(CFLAGS) -DTEST -o $@ $@.c $(LIB) $(SYSLIBS)
 mv junk $@.o

normalize_v4mapped_addr_test: normalize_v4mapped_addr_test.c $(LIB)
 $(CC) $(CFLAGS) -o $@ normalize_v4mapped_addr_test.c $(LIB) $(SYSLIBS)

ossl_digest_test: ossl_digest_test.c $(LIB)
 $(CC) $(CFLAGS) -o $@ $@.c $(LIB) $(SYSLIBS)

dict_pipe_test: dict_pipe_test.c $(TESTLIB) $(LIB)
 $(CC) $(CFLAGS) -o $@ $@.c $(TESTLIB) $(LIB) $(SYSLIBS)

dict_union_test: dict_union_test.c $(TESTLIB) $(LIB)
 $(CC) $(CFLAGS) -o $@ $@.c $(TESTLIB) $(LIB) $(SYSLIBS)

tests: all valid_hostname_test mac_expand_test dict_test unescape_test \
 hex_quote_test ctable_test inet_addr_list_test base64_code_test \
 attr_scan64_test attr_scan0_test host_port_test dict_tests \
 attr_scan_plain_test htable_test hex_code_test myaddrinfo_test \
 format_tv_test ip_match_test name_mask_tests base32_code_test \
 surrogate_test timecmp_test midna_domain_test casefold_test \
 strcasecmp_utf8_test vbuf_print_test miss_endif_cidr_test \
 miss_endif_regexp_test split_qnameval_test vstring_test \
 vstream_test byte_mask_tests mystrtok_test known_tcp_ports_test \
 binhash_test argv_test inet_prefix_top_test printable_test \
 valid_utf8_string_test readlline_test quote_for_json_test \
 normalize_ws_test valid_uri_scheme_test clean_ascii_cntrl_space_test \
 test_normalize_v4mapped_addr test_ossl_digest test_dict_pipe \
 test_dict_union test_hash_fnv
 
dict_tests: all dict_test \
 dict_pcre_tests dict_cidr_test dict_thash_test dict_static_test \
 dict_inline_test dict_utf8_test dict_regexp_test \
 dict_regexp_file_test dict_cidr_file_test dict_seq_test \
 dict_static_file_test dict_random_test dict_random_file_test \
 dict_inline_file_test dict_stream_test dict_inline_regexp_test \
 dict_inline_cidr_test dict_debug_test

dict_pcre_tests: dict_pcre_test miss_endif_pcre_test dict_pcre_file_test \
 dict_inline_pcre_test

root_tests:

valid_hostname_test: valid_hostname valid_hostname.in valid_hostname.ref
 $(SHLIB_ENV) ${VALGRIND} ./valid_hostname <valid_hostname.in 2>valid_hostname.tmp
 diff valid_hostname.ref valid_hostname.tmp
 rm -f valid_hostname.tmp

mac_expand_test: mac_expand mac_expand.in mac_expand.ref
 $(SHLIB_ENV) ${VALGRIND} ./mac_expand <mac_expand.in >mac_expand.tmp 2>&1
 diff mac_expand.ref mac_expand.tmp
 rm -f mac_expand.tmp

unescape_test: unescape unescape.in unescape.ref
 $(SHLIB_ENV) ${VALGRIND} ./unescape <unescape.in | LANG=C od -cb >unescape.tmp
 diff -b unescape.ref unescape.tmp
$(SHLIB_ENV) ${VALGRIND} ./unescape <unescape.in | $(SHLIB_ENV) ${VALGRIND} ./unescape -e >unescape.tmp
diff unescape.in unescape.tmp
 rm -f unescape.tmp

printable_test: printable
 $(SHLIB_ENV) ${VALGRIND} ./printable 

readlline_test: readlline
 $(SHLIB_ENV) ${VALGRIND} ./readlline 

valid_utf8_string_test: valid_utf8_string
 $(SHLIB_ENV) ${VALGRIND} ./valid_utf8_string 

hex_quote_test: hex_quote
 $(SHLIB_ENV) ${VALGRIND} ./hex_quote <hex_quote.c | od -cb >hex_quote.tmp
 od -cb <hex_quote.c >hex_quote.ref
 cmp hex_quote.ref hex_quote.tmp
 rm -f hex_quote.ref hex_quote.tmp

ctable_test: ctable
 $(SHLIB_ENV) ${VALGRIND} ./ctable <ctable.in >ctable.tmp 2>&1
 diff ctable.ref ctable.tmp
 rm -f ctable.tmp

On Linux, following test may require "modprobe ipv6" to enable IPv6.

inet_addr_list_test: inet_addr_list
 $(SHLIB_ENV) ${VALGRIND} ./inet_addr_list `cat inet_addr_list.in` >inet_addr_list.tmp 2>&<span style='color: green'>1
 diff inet_addr_list.ref inet_addr_list.tmp
 rm -f inet_addr_list.tmp

sane_basename_test: sane_basename
 $(SHLIB_ENV) ${VALGRIND} ./sane_basename <sane_basename.in >sane_basename.tmp 2>&le='color: green'>1
 diff sane_basename.ref sane_basename.tmp
 rm -f sane_basename.tmp

base64_code_test: base64_code
 $(SHLIB_ENV) ${VALGRIND} ./base64_code

attr_scan64_test: attr_print64 attr_scan64 attr_scan64.ref
 ($(HTABLE_FIX) $(SHLIB_ENV) ${VALGRIND} ./attr_print64 2>&3 | (sleep 1; $(HTABLE_FIX) $(SHLIB_ENV) ${VALGRIND} ./attr_scan64)) >attr_scan64.tmp 2>&tyle='color: green'>1 3>&1
 diff attr_scan64.ref attr_scan64.tmp
 rm -f attr_scan64.tmp

attr_scan0_test: attr_print0 attr_scan0 attr_scan0.ref
 ($(HTABLE_FIX) $(SHLIB_ENV) ${VALGRIND} ./attr_print0 2>&3 | (sleep 1; $(HTABLE_FIX) $(SHLIB_ENV) ${VALGRIND} ./attr_scan0)) >attr_scan0.tmp 2>&e='color: green'>1 3>&1
 diff attr_scan0.ref attr_scan0.tmp
 rm -f attr_scan0.tmp

dict_test: dict_open testdb dict_test.in dict_test.ref
 rm -f testdb.db testdb.dir testdb.pag
 $(SHLIB_ENV) ../postmap/postmap -N hash:testdb
 $(SHLIB_ENV) ${VALGRIND} ./dict_open hash:testdb write < dict_test.in 2>&1 | sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' >dict_test.tmp
 diff dict_test.ref dict_test.tmp
 $(SHLIB_ENV) ../postmap/postmap -n hash:testdb
 $(SHLIB_ENV) ${VALGRIND} ./dict_open hash:testdb write < dict_test.in 2>&1 | sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' >dict_test.tmp
 diff dict_test.ref dict_test.tmp
 rm -f testdb.db testdb.dir testdb.pag dict_test.tmp

dict_pcre_test: dict_open dict_pcre.in dict_pcre.map dict_pcre.ref
 $(SHLIB_ENV) ${VALGRIND} ./dict_open pcre:dict_pcre.map read \
     <dict_pcre.in 2>&1 | sed -e 's/uid=[0-9][0-9][0-9]*/uid=USER/' \
     -e 's/missing )/missing closing parenthesis/' >dict_pcre.tmp
 diff dict_pcre.ref dict_pcre.tmp
 rm -f dict_pcre.tmp

dict_pcre_file_test: dict_open dict_pcre_file.in dict_pcre_file.map dict_pcre_file.ref
 echo this-is-file1 > dict_pcre_file1
 echo this-is-file2 > dict_pcre_file2
 $(SHLIB_ENV) ${VALGRIND} ./dict_open pcre:dict_pcre_file.map \
     read src_rhs_is_file <dict_pcre_file.in 2>&1 | \
     sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' >dict_pcre_file.tmp
 diff dict_pcre_file.ref dict_pcre_file.tmp
 rm -f dict_pcre_file.tmp dict_pcre_file1 dict_pcre_file2

dict_regexp_test: dict_open dict_regexp.in dict_regexp.map dict_regexp.ref
 $(SHLIB_ENV) ${VALGRIND} ./dict_open regexp:dict_regexp.map read <dict_regexp.in 2>&style='color: green'>1 | sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' >dict_regexp.tmp
 diff dict_regexp.ref dict_regexp.tmp
 rm -f dict_regexp.tmp

dict_regexp_file_test: dict_open dict_regexp_file.in dict_regexp_file.map dict_regexp_file.ref
 echo this-is-file1 > dict_regexp_file1
 echo this-is-file2 > dict_regexp_file2
 $(SHLIB_ENV) ${VALGRIND} ./dict_open regexp:dict_regexp_file.map \
     read src_rhs_is_file <dict_regexp_file.in 2>&1 | \
     sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' >dict_regexp_file.tmp
 diff dict_regexp_file.ref dict_regexp_file.tmp
 rm -f dict_regexp_file.tmp dict_regexp_file1 dict_regexp_file2

dict_cidr_test: dict_open dict_cidr.in dict_cidr.map dict_cidr.ref
 $(SHLIB_ENV) ${VALGRIND} ./dict_open cidr:dict_cidr.map read <dict_cidr.in 2>&'color: green'>1 | sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' >dict_cidr.tmp
 diff dict_cidr.ref dict_cidr.tmp
 rm -f dict_cidr.tmp

dict_cidr_file_test: dict_open dict_cidr_file.in dict_cidr_file.map dict_cidr_file.ref
 echo this-is-file1 > dict_cidr_file1
 echo this-is-file2 > dict_cidr_file2
 $(SHLIB_ENV) ${VALGRIND} ./dict_open cidr:dict_cidr_file.map \
     read src_rhs_is_file <dict_cidr_file.in 2>&1 | \
     sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' >dict_cidr_file.tmp
 diff dict_cidr_file.ref dict_cidr_file.tmp
 rm -f dict_cidr_file.tmp dict_cidr_file1 dict_cidr_file2

miss_endif_cidr_test: dict_open miss_endif_cidr.map miss_endif_cidr.ref
 echo get 1.2.3.5 | $(SHLIB_ENV) ${VALGRIND} ./dict_open cidr:miss_endif_cidr.map read 2>&an style='color: green'>1 | sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' >dict_cidr.tmp
 diff miss_endif_cidr.ref dict_cidr.tmp
 rm -f dict_cidr.tmp

miss_endif_pcre_test: dict_open miss_endif_re.map miss_endif_pcre.ref
 echo get 1.2.3.5 | $(SHLIB_ENV) ${VALGRIND} ./dict_open pcre:miss_endif_re.map read 2>& style='color: green'>1 | sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' >dict_pcre.tmp
 diff miss_endif_pcre.ref dict_pcre.tmp
 rm -f dict_pcre.tmp

miss_endif_regexp_test: dict_open miss_endif_re.map miss_endif_regexp.ref
 echo get 1.2.3.5 | $(SHLIB_ENV) ${VALGRIND} ./dict_open regexp:miss_endif_re.map read 2>&an style='color: green'>1 | sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' >dict_regexp.tmp
 diff miss_endif_regexp.ref dict_regexp.tmp
 rm -f dict_regexp.tmp

split_qnameval_test: split_qnameval update
 $(SHLIB_ENV) ${VALGRIND} ./split_qnameval

dict_seq_test: dict_open testdb dict_seq.in dict_seq.ref
 rm -f testdb.db testdb.dir testdb.pag
 ${HTABLE_FIX} $(SHLIB_ENV) ${VALGRIND} ./dict_open internal:testdb create sync_update < dict_seq.in 2>&1 | sed 's/uid=[0-9][0-9][0-9]*/uid=USER/' > dict_seq.tmp
 diff dict_seq.ref dict_seq.tmp
 rm -f testdb.db testdb.dir testdb.pag dict_seq.tmp

host_port_test: host_port host_port.in host_port.ref
 $(SHLIB_ENV) ${VALGRIND} ./host_port <host_port.in >host_port.tmp 2>&1
 diff host_port.ref host_port.tmp
 rm -f host_port.tmp

attr_scan_plain_test: attr_print_plain attr_scan_plain attr_scan_plain.ref
 ($(HTABLE_FIX) $(SHLIB_ENV) ${VALGRIND} ./attr_print_plain 2>&3 | (sleep 1; $(HTABLE_FIX) $(SHLIB_ENV) ${VALGRIND} ./attr_scan_plain)) >attr_scan_plain.tmp 2>&1 3>&1
 diff attr_scan_plain.ref attr_scan_plain.tmp
 rm -f attr_scan_plain.tmp

htable_test: htable /usr/share/dict/words
 $(SHLIB_ENV) ${VALGRIND} ./htable < /usr/share/dict/words

binhash_test: binhash /usr/share/dict/words
 $(SHLIB_ENV) ${VALGRIND} ./binhash < /usr/share/dict/words

test_hash_fnv: hash_fnv_test
 $(SHLIB_ENV) ${VALGRIND} ./hash_fnv_test

hex_code_test: hex_code
 $(SHLIB_ENV) ${VALGRIND} ./hex_code

timecmp_test: timecmp
 $(SHLIB_ENV) ${VALGRIND} ./timecmp

myaddrinfo_test: myaddrinfo myaddrinfo.ref myaddrinfo.ref2
 $(SHLIB_ENV) ${VALGRIND} ./myaddrinfo all belly.porcupine.org 168.100.3.2 >myaddrinfo.tmp 2>&1
 diff myaddrinfo.ref myaddrinfo.tmp
 rm -f myaddrinfo.tmp
 $(SHLIB_ENV) ${VALGRIND} ./myaddrinfo all null.porcupine.org 10.0.0.0 >myaddrinfo.tmp 2>&pan style='color: green'>1
 diff myaddrinfo.ref2 myaddrinfo.tmp
 rm -f myaddrinfo.tmp

myaddrinfo4_test: myaddrinfo4 myaddrinfo4.ref myaddrinfo4.ref2
 $(SHLIB_ENV) ${VALGRIND} ./myaddrinfo4 all belly.porcupine.org 168.100.3.2 >myaddrinfo4.tmp 2>&1
 diff myaddrinfo4.ref myaddrinfo4.tmp
 $(SHLIB_ENV) ${VALGRIND} ./myaddrinfo4 all null.porcupine.org 10.0.0.0 >myaddrinfo4.tmp 2>&1
 diff myaddrinfo4.ref2 myaddrinfo4.tmp
 rm -f myaddrinfo4.tmp

format_tv_test: format_tv format_tv.in format_tv.ref
 $(SHLIB_ENV) ${VALGRIND} ./format_tv <format_tv.in >format_tv.tmp
 diff format_tv.ref format_tv.tmp
 rm -f format_tv.tmp

ip_match_test: ip_match ip_match.in ip_match.ref
 $(SHLIB_ENV) ${VALGRIND} ./ip_match <ip_match.in >ip_match.tmp
 diff ip_match.ref ip_match.tmp
 rm -f ip_match.tmp

name_mask_tests: name_mask_test0 name_mask_test1 name_mask_test2 \
 name_mask_test3 name_mask_test4 name_mask_test5 name_mask_test6 \
 name_mask_test7 name_mask_test8 name_mask_test9

name_mask_test0: name_mask name_mask.in name_mask.ref0
 $(SHLIB_ENV) ${VALGRIND} ./name_mask IGNORE IGNORE < name_mask.in > name_mask.tmp 2>&le='color: green'>1
 diff name_mask.ref0 name_mask.tmp
 rm -f name_mask.tmp

name_mask_test1: name_mask name_mask.in name_mask.ref1
 $(SHLIB_ENV) ${VALGRIND} ./name_mask NUMBER,WARN NUMBER < name_mask.in > name_mask.tmp 2>&n style='color: green'>1
 diff name_mask.ref1 name_mask.tmp
 rm -f name_mask.tmp

name_mask_test2: name_mask name_mask.in name_mask.ref2
 $(SHLIB_ENV) ${VALGRIND} ./name_mask NUMBER,RETURN NUMBER < name_mask.in > name_mask.tmp 2>&pan style='color: green'>1
 diff name_mask.ref2 name_mask.tmp
 rm -f name_mask.tmp

name_mask_test3: name_mask name_mask.in name_mask.ref3
 $(SHLIB_ENV) ${VALGRIND} ./name_mask WARN NUMBER < name_mask.in > name_mask.tmp 2>&='color: green'>1
 diff name_mask.ref3 name_mask.tmp
 rm -f name_mask.tmp

name_mask_test4: name_mask name_mask.in name_mask.ref4
 $(SHLIB_ENV) ${VALGRIND} ./name_mask RETURN NUMBER < name_mask.in > name_mask.tmp 2>&le='color: green'>1
 diff name_mask.ref4 name_mask.tmp
 rm -f name_mask.tmp

name_mask_test5: name_mask name_mask.in name_mask.ref5
 $(SHLIB_ENV) ${VALGRIND} ./name_mask NUMBER,WARN RETURN < name_mask.in > name_mask.tmp 2>&n style='color: green'>1
 diff name_mask.ref5 name_mask.tmp
 rm -f name_mask.tmp

name_mask_test6: name_mask name_mask.in name_mask.ref6
 $(SHLIB_ENV) ${VALGRIND} ./name_mask NUMBER,WARN WARN < name_mask.in > name_mask.tmp 2>&style='color: green'>1
 diff name_mask.ref6 name_mask.tmp
 rm -f name_mask.tmp

name_mask_test7: name_mask name_mask.in name_mask.ref7
 $(SHLIB_ENV) ${VALGRIND} ./name_mask NUMBER,WARN IGNORE < name_mask.in > name_mask.tmp 2>&n style='color: green'>1
 diff name_mask.ref7 name_mask.tmp
 rm -f name_mask.tmp

name_mask_test8: name_mask name_mask.in name_mask.ref8
 $(SHLIB_ENV) ${VALGRIND} ./name_mask NUMBER,WARN NUMBER,COMMA < name_mask.in > name_mask.tmp 2>&1
 diff name_mask.ref8 name_mask.tmp
 rm -f name_mask.tmp

name_mask_test9: name_mask name_mask.in name_mask.ref9
 $(SHLIB_ENV) ${VALGRIND} ./name_mask NUMBER,WARN NUMBER,PIPE < name_mask.in > name_mask.tm2>&1
 diff name_mask.ref9 name_mask.tmp
 rm -f name_mask.tmp

byte_mask_tests: byte_mask_test0 byte_mask_test1 byte_mask_test2

byte_mask_test0: byte_mask byte_mask.in byte_mask.ref0
 while read line; do \
     echo "$$line" | $(SHLIB_ENV) ${VALGRIND} ./byte_mask IGNORE IGNORE; \
 done < byte_mask.in > byte_mask.tmp 2>&1
 diff byte_mask.ref0 byte_mask.tmp
 rm -f byte_mask.tmp

byte_mask_test1: byte_mask byte_mask.in byte_mask.ref1
 while read line; do \
     echo "$$line" | $(SHLIB_ENV) ${VALGRIND} ./byte_mask WARN WARN; \
 done < byte_mask.in > byte_mask.tmp 2>&1
 diff byte_mask.ref1 byte_mask.tmp
 rm -f byte_mask.tmp

byte_mask_test2: byte_mask byte_mask.in byte_mask.ref2
 -while read line; do \
     echo "$$line" | $(SHLIB_ENV) ${VALGRIND} ./byte_mask FATAL FATAL; \
 done < byte_mask.in > byte_mask.tmp 2>&1
 diff byte_mask.ref2 byte_mask.tmp
 rm -f byte_mask.tmp

base32_code_test: base32_code
 $(SHLIB_ENV) ${VALGRIND} ./base32_code

dict_thash_test: ../postmap/postmap dict_thash.map dict_thash.in dict_thash.ref
 $(SHLIB_ENV) ${VALGRIND} ../postmap/postmap -fs texthash:dict_thash.map 2>&1 | \
     LANG=C sort | diff dict_thash.map -
 NORANDOMIZE=1 $(SHLIB_ENV) ${VALGRIND} ../postmap/postmap -fs texthash:dict_thash.in >dict_thash.tmp 2>&1
 diff dict_thash.ref dict_thash.tmp
 rm -f dict_thash.tmp

surrogate_test: dict_open surrogate.ref
 cp /dev/null surrogate.tmp
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open cidr:/xx write >>surrogate.tmp 2>&le='color: green'>1
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open cidr:/xx read >>surrogate.tmp 2>&e='color: green'>1
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open pcre:/xx write >>surrogate.tmp 2>&le='color: green'>1
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open pcre:/xx read >>surrogate.tmp 2>&e='color: green'>1
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open regexp:/xx write >>surrogate.tmp 2>&tyle='color: green'>1
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open regexp:/xx read >>surrogate.tmp 2>&yle='color: green'>1
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open unix:xx write >>surrogate.tmp 2>&e='color: green'>1
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open unix:xx read >>surrogate.tmp 2>&='color: green'>1
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open texthash:/xx write >>surrogate.tmp 2>& style='color: green'>1
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open texthash:/xx read >>surrogate.tmp 2>&style='color: green'>1
 echo get foo|$(SHLIB_ENV) ${VALGRIND} ./dict_open hash:/xx read >>surrogate.tmp 2>&e='color: green'>1
 diff surrogate.ref surrogate.tmp
 rm -f surrogate.tmp

dict_static_test: dict_open dict_static.ref
 (set -e; \
 (echo get foo; echo get bar) | $(SHLIB_ENV) \
     ${VALGRIND} ./dict_open static:fooxx read; \
 $(SHLIB_ENV) ${VALGRIND} ./dict_open static:'{ foo xx ' read </dev/null; \
 $(SHLIB_ENV) ${VALGRIND} ./dict_open static:'{ foo xx }x' read </dev/null; \
 (echo get foo; echo get bar) | $(SHLIB_ENV) \
     ${VALGRIND} ./dict_open static:'{ foo xx }' read; \
 ) >dict_static.tmp 2>&1
 diff dict_static.ref dict_static.tmp
 rm -f dict_static.tmp

dict_static_file_test: dict_open dict_static_file.ref
 echo this-is-file1 > dict_static_file1
 (set -e; \
 echo get foo | $(SHLIB_ENV) \
     ${VALGRIND} ./dict_open static:fooxx read src_rhs_is_file; \
 (echo get file1; echo get file2) | $(SHLIB_ENV) \
     ${VALGRIND} ./dict_open static:'{ dict_static_file1 }' read src_rhs_is_file; \
 ) >dict_static_file.tmp 2>&1
 diff dict_static_file.ref dict_static_file.tmp
 rm -f dict_static_file.tmp dict_static_file1

dict_random_test: dict_open dict_random.ref
 (set -e; \
 (echo get foo; echo get bar) | $(SHLIB_ENV) \
     ${VALGRIND} ./dict_open randmap:'{123 123}' read; \
 echo get foo | $(SHLIB_ENV) ${VALGRIND} ./dict_open randmap:123 read; \
 echo get foo | $(SHLIB_ENV) ${VALGRIND} ./dict_open randmap:'{ 123 ' read; \
 echo get foo | $(SHLIB_ENV) ${VALGRIND} ./dict_open randmap:'{ 123 }x' read; \
 ) >dict_random.tmp 2>&1
 diff dict_random.ref dict_random.tmp
 rm -f dict_random.tmp

dict_random_file_test: dict_open dict_random_file.ref
 echo this-is-file1 > dict_random_file1
 (set -e; \
 echo get foo | $(SHLIB_ENV) \
     ${VALGRIND} ./dict_open randmap:'{fooxx}' read src_rhs_is_file; \
 (echo get foo; echo get bar) | $(SHLIB_ENV) \
     ${VALGRIND} ./dict_open randmap:'{ dict_random_file1 }' read src_rhs_is_file; \
 ) >dict_random_file.tmp 2>&1
 diff dict_random_file.ref dict_random_file.tmp
 rm -f dict_random_file.tmp dict_random_file1

dict_inline_test: dict_open dict_inline.ref
 (set -e; \
 $(SHLIB_ENV) ${VALGRIND} ./dict_open inline:'{ }' read </dev/null; \
 $(SHLIB_ENV) ${VALGRIND} ./dict_open inline:'{ foo = xx }' read </dev/null; \
 $(SHLIB_ENV) ${VALGRIND} ./dict_open inline:'{ foo=xx }x' read </dev/null; \
 $(SHLIB_ENV) ${VALGRIND} ./dict_open inline:'{ foo=xx x' read </dev/null; \
 $(SHLIB_ENV) ${VALGRIND} ./dict_open inline:'{ foo=xx {x=y}x}' read </dev/null; \
 (echo get foo; echo get bar; echo get baz) | $(SHLIB_ENV) \
     ${VALGRIND} ./dict_open inline:'{ foo=XX, { bAr = lotsa stuff }}' read fold_fix; \
 (echo get foo; echo get bar; echo get baz) | $(SHLIB_ENV) \
     ${VALGRIND} ./dict_open inline:'{ foo=XX, { bAr = lotsa stuff }}' read 'fold_fix,utf8_request'; \
 ) >dict_inline.tmp 2>&1
 diff dict_inline.ref dict_inline.tmp
 rm -f dict_inline.tmp

dict_inline_file_test: dict_open dict_inline_file.ref
 (set -e; \
 echo get foo | $(SHLIB_ENV) ${VALGRIND} \
     ./dict_open inline:'{ foo=xx, bar=yy }' read src_rhs_is_file; \
 echo this-is-file1 > dict_inline_file1; \
 echo this-is-file2 > dict_inline_file2; \
 (echo get file1; echo get file2; echo get file3) | $(SHLIB_ENV) \
     ${VALGRIND} ./dict_open inline:'{ file1=dict_inline_file1, file2=dict_inline_file2}' read src_rhs_is_file; \
 ) >dict_inline_file.tmp 2>&1
 diff dict_inline_file.ref dict_inline_file.tmp
 rm -f dict_inline_file.tmp dict_inline_file1 dict_inline_file2

midna_domain_test: midna_domain midna_domain_test.in midna_domain_test.ref
 $(SHLIB_ENV) ${VALGRIND} ./midna_domain <midna_domain_test.in >midna_domain_test.tmp 2>&pan style='color: green'>1
 diff midna_domain_test.ref midna_domain_test.tmp
 rm -f midna_domain_test.tmp

casefold_test: casefold casefold_test.in casefold_test.ref
 $(SHLIB_ENV) ${VALGRIND} ./casefold <casefold_test.in >casefold_test.tmp 2>&1
 diff casefold_test.ref casefold_test.tmp
 rm -f casefold_test.tmp

dict_utf8_test: dict_open dict_utf8_test.in dict_utf8_test.ref
 $(SHLIB_ENV) sh dict_utf8_test.in >dict_utf8_test.tmp 2>&1
 diff dict_utf8_test.ref dict_utf8_test.tmp
 rm -f dict_utf8_test.tmp

strcasecmp_utf8_test: strcasecmp_utf8 strcasecmp_utf8_test.in \
 strcasecmp_utf8_test.ref
 $(SHLIB_ENV) ${VALGRIND} ./strcasecmp_utf8 <strcasecmp_utf8_test.in >strcasecmp_utf8_test.tmp 2>&1
 diff strcasecmp_utf8_test.ref strcasecmp_utf8_test.tmp
 rm -f strcasecmp_utf8_test.tmp

vbuf_print_test: vbuf_print vbuf_print_test.in vbuf_print_test.ref
 $(SHLIB_ENV) ${VALGRIND} ./vbuf_print <vbuf_print_test.in >vbuf_print_test.tmp 2>&yle='color: green'>1
 diff vbuf_print_test.ref vbuf_print_test.tmp
 rm -f vbuf_print_test.tmp

vstring_test: dict_open vstring vstring_test.ref
 $(SHLIB_ENV) ${VALGRIND} ./vstring one two three >vstring_test.tmp 2>&1
 diff vstring_test.ref vstring_test.tmp
 rm -f vstring_test.tmp

vstream_test: vstream vstream_test.in vstream_test.ref
 $(SHLIB_ENV) ${VALGRIND} ./vstream <vstream_test.in >vstream_test.tmp 2>&1
 diff vstream_test.ref vstream_test.tmp
 rm -f vstream_test.tmp

mystrtok_test: mystrtok mystrtok.ref
 $(SHLIB_ENV) ${VALGRIND} ./mystrtok >mystrtok.tmp 2>&1
 diff mystrtok.ref mystrtok.tmp
 rm -f mystrtok.tmp

known_tcp_ports_test: known_tcp_ports known_tcp_ports.ref
 $(SHLIB_ENV) ${VALGRIND} ./known_tcp_ports >known_tcp_ports.tmp 2>&1
 diff known_tcp_ports.ref known_tcp_ports.tmp
 rm -f known_tcp_ports.tmp

dict_stream_test: dict_stream dict_stream.ref
 $(SHLIB_ENV) ${VALGRIND} ./dict_stream >dict_stream.tmp 2>&1
 diff dict_stream.ref dict_stream.tmp
 rm -f dict_stream.tmp

dict_inline_pcre_test: dict_open dict_inline_pcre.ref
 (echo get foo; echo get bar) | \
     $(SHLIB_ENV) ${VALGRIND} ./dict_open 'pcre:{{/foo/ got foo}}' \
     read 2>&1 | grep -v uid= >dict_inline_pcre.tmp
 diff dict_inline_pcre.ref dict_inline_pcre.tmp
 rm -f dict_inline_pcre.tmp

dict_inline_regexp_test: dict_open dict_inline_regexp.ref
 (echo get foo; echo get bar) | \
     $(SHLIB_ENV) ${VALGRIND} ./dict_open 'regexp:{{/foo/ got foo}}' \
     read 2>&1 | grep -v uid= >dict_inline_regexp.tmp
 diff dict_inline_regexp.ref dict_inline_regexp.tmp
 rm -f dict_inline_regexp.tmp

dict_inline_cidr_test: dict_open dict_inline_cidr.ref
 (echo get 1.2.3.4; echo get 4.3.2.1) | \
     $(SHLIB_ENV) ${VALGRIND} ./dict_open \
  'cidr:{{1.2.3.4 got 1.2.3.4}}' \
  read 2>&1 | grep -v uid= >dict_inline_cidr.tmp
 diff dict_inline_cidr.ref dict_inline_cidr.tmp
 rm -f dict_inline_cidr.tmp

dict_debug_test: dict_open dict_debug_test.sh dict_debug_test.ref
 $(SHLIB_ENV) ./dict_debug_test.sh >dict_debug_test.tmp 2>&1
 diff dict_debug_test.ref dict_debug_test.tmp
 rm -f dict_debug_test.tmp

find_inet_test: find_inet find_inet.ref
 $(SHLIB_ENV) ${VALGRIND} ./find_inet >find_inet.tmp 2>&1
 diff find_inet.ref find_inet.tmp
 rm -f find_inet.tmp

argv_test: argv
 $(SHLIB_ENV) ${VALGRIND} ./argv

inet_prefix_top_test: inet_prefix_top
 $(SHLIB_ENV) ${VALGRIND} ./inet_prefix_top

quote_for_json_test: quote_for_json
 $(SHLIB_ENV) ${VALGRIND} ./quote_for_json

normalize_ws_test: normalize_ws
 $(SHLIB_ENV) ${VALGRIND} ./normalize_ws

valid_uri_scheme_test: valid_uri_scheme
 $(SHLIB_ENV) ${VALGRIND} ./valid_uri_scheme

clean_ascii_cntrl_space_test: clean_ascii_cntrl_space
 $(SHLIB_ENV) ${VALGRIND} ./clean_ascii_cntrl_space

test_normalize_v4mapped_addr: update normalize_v4mapped_addr_test
 $(SHLIB_ENV) ${VALGRIND} ./normalize_v4mapped_addr_test

test_ossl_digest: update ossl_digest_test
 $(SHLIB_ENV) ${VALGRIND} ./ossl_digest_test

test_dict_pipe: update dict_pipe_test
 $(SHLIB_ENV) ${VALGRIND} ./dict_pipe_test

test_dict_union: update dict_union_test
 $(SHLIB_ENV) ${VALGRIND} ./dict_union_test

depend: $(MAKES)
 (sed '1,/^# do not edit/!d' Makefile.in; \
 set -e; for i in [a-z][a-z0-9]*.c; do \
     $(CC) -E $(DEFS) $(INCL) $$i | grep -v '[<>]' | sed -n -e '/^# *1 *"\([^"]*\)".*/{' \
     -e 's//'`echo $$i|sed 's/c$$/o/'`': \1/' \
     -e 's/o: \.\//o: /' -e p -e '}' ; \
 done | LANG=C sort -u) | grep -v '[.][o][:][ ][/]' >$$$$ && mv $$$$ Makefile.in
 @$(EXPORT) make -f Makefile.in Makefile 1>&2

do not edit below this line - it is generated by 'make depend'
allascii.o: allascii.c
allascii.o: check_arg.h
allascii.o: stringops.h
allascii.o: sys_defs.h
allascii.o: vbuf.h
allascii.o: vstring.h
alldig.o: alldig.c
alldig.o: check_arg.h
alldig.o: stringops.h
alldig.o: sys_defs.h
alldig.o: vbuf.h
alldig.o: vstring.h
allprint.o: allprint.c
allprint.o: check_arg.h
allprint.o: stringops.h
allprint.o: sys_defs.h
allprint.o: vbuf.h
allprint.o: vstring.h
allspace.o: allspace.c
allspace.o: check_arg.h
allspace.o: stringops.h
allspace.o: sys_defs.h
allspace.o: vbuf.h
allspace.o: vstring.h
argv.o: argv.c
argv.o: argv.h
argv.o: check_arg.h
argv.o: msg.h
argv.o: mymalloc.h
argv.o: sys_defs.h
argv.o: vbuf.h
argv.o: vstring.h
argv_attr_print.o: argv.h
argv_attr_print.o: argv_attr.h
argv_attr_print.o: argv_attr_print.c
argv_attr_print.o: attr.h
argv_attr_print.o: check_arg.h
argv_attr_print.o: htable.h
argv_attr_print.o: msg.h
argv_attr_print.o: mymalloc.h
argv_attr_print.o: nvtable.h
argv_attr_print.o: sys_defs.h
argv_attr_print.o: vbuf.h
argv_attr_print.o: vstream.h
argv_attr_print.o: vstring.h
argv_attr_scan.o: argv.h
argv_attr_scan.o: argv_attr.h
argv_attr_scan.o: argv_attr_scan.c
argv_attr_scan.o: attr.h
argv_attr_scan.o: check_arg.h
argv_attr_scan.o: htable.h
argv_attr_scan.o: msg.h
argv_attr_scan.o: mymalloc.h
argv_attr_scan.o: nvtable.h
argv_attr_scan.o: sys_defs.h
argv_attr_scan.o: vbuf.h
argv_attr_scan.o: vstream.h
argv_attr_scan.o: vstring.h
argv_split.o: argv.h
argv_split.o: argv_split.c
argv_split.o: check_arg.h
argv_split.o: msg.h
argv_split.o: mymalloc.h
argv_split.o: stringops.h
argv_split.o: sys_defs.h
argv_split.o: vbuf.h
argv_split.o: vstring.h
argv_split_at.o: argv.h
argv_split_at.o: argv_split_at.c
argv_split_at.o: check_arg.h
argv_split_at.o: msg.h
argv_split_at.o: mymalloc.h
argv_split_at.o: split_at.h
argv_split_at.o: stringops.h
argv_split_at.o: sys_defs.h
argv_split_at.o: vbuf.h
argv_split_at.o: vstring.h
argv_splitq.o: argv.h
argv_splitq.o: argv_splitq.c
argv_splitq.o: check_arg.h
argv_splitq.o: msg.h
argv_splitq.o: mymalloc.h
argv_splitq.o: stringops.h
argv_splitq.o: sys_defs.h
argv_splitq.o: vbuf.h
argv_splitq.o: vstring.h
attr_clnt.o: attr.h
attr_clnt.o: attr_clnt.c
attr_clnt.o: attr_clnt.h
attr_clnt.o: auto_clnt.h
attr_clnt.o: check_arg.h
attr_clnt.o: compat_va_copy.h
attr_clnt.o: htable.h
attr_clnt.o: iostuff.h
attr_clnt.o: msg.h
attr_clnt.o: mymalloc.h
attr_clnt.o: nvtable.h
attr_clnt.o: sys_defs.h
attr_clnt.o: vbuf.h
attr_clnt.o: vstream.h
attr_clnt.o: vstring.h
attr_print0.o: attr.h
attr_print0.o: attr_print0.c
attr_print0.o: base64_code.h
attr_print0.o: check_arg.h
attr_print0.o: htable.h
attr_print0.o: msg.h
attr_print0.o: mymalloc.h
attr_print0.o: nvtable.h
attr_print0.o: sys_defs.h
attr_print0.o: vbuf.h
attr_print0.o: vstream.h
attr_print0.o: vstring.h
attr_print64.o: attr.h
attr_print64.o: attr_print64.c
attr_print64.o: base64_code.h
attr_print64.o: check_arg.h
attr_print64.o: htable.h
attr_print64.o: msg.h
attr_print64.o: mymalloc.h
attr_print64.o: nvtable.h
attr_print64.o: sys_defs.h
attr_print64.o: vbuf.h
attr_print64.o: vstream.h
attr_print64.o: vstring.h
attr_print_plain.o: attr.h
attr_print_plain.o: attr_print_plain.c
attr_print_plain.o: base64_code.h
attr_print_plain.o: check_arg.h
attr_print_plain.o: htable.h
attr_print_plain.o: msg.h
attr_print_plain.o: mymalloc.h
attr_print_plain.o: nvtable.h
attr_print_plain.o: sys_defs.h
attr_print_plain.o: vbuf.h
attr_print_plain.o: vstream.h
attr_print_plain.o: vstring.h
attr_scan0.o: attr.h
attr_scan0.o: attr_scan0.c
attr_scan0.o: base64_code.h
attr_scan0.o: check_arg.h
attr_scan0.o: htable.h
attr_scan0.o: msg.h
attr_scan0.o: mymalloc.h
attr_scan0.o: nvtable.h
attr_scan0.o: stringops.h
attr_scan0.o: sys_defs.h
attr_scan0.o: vbuf.h
attr_scan0.o: vstream.h
attr_scan0.o: vstring.h
attr_scan0.o: vstring_vstream.h
attr_scan64.o: attr.h
attr_scan64.o: attr_scan64.c
attr_scan64.o: base64_code.h
attr_scan64.o: check_arg.h
attr_scan64.o: htable.h
attr_scan64.o: msg.h
attr_scan64.o: mymalloc.h
attr_scan64.o: nvtable.h
attr_scan64.o: stringops.h
attr_scan64.o: sys_defs.h
attr_scan64.o: vbuf.h
attr_scan64.o: vstream.h
attr_scan64.o: vstring.h
attr_scan_plain.o: attr.h
attr_scan_plain.o: attr_scan_plain.c
attr_scan_plain.o: base64_code.h
attr_scan_plain.o: check_arg.h
attr_scan_plain.o: htable.h
attr_scan_plain.o: msg.h
attr_scan_plain.o: mymalloc.h
attr_scan_plain.o: nvtable.h
attr_scan_plain.o: stringops.h
attr_scan_plain.o: sys_defs.h
attr_scan_plain.o: vbuf.h
attr_scan_plain.o: vstream.h
attr_scan_plain.o: vstring.h
auto_clnt.o: auto_clnt.c
auto_clnt.o: auto_clnt.h
auto_clnt.o: check_arg.h
auto_clnt.o: connect.h
auto_clnt.o: events.h
auto_clnt.o: iostuff.h
auto_clnt.o: msg.h
auto_clnt.o: mymalloc.h
auto_clnt.o: split_at.h
auto_clnt.o: sys_defs.h
auto_clnt.o: vbuf.h
auto_clnt.o: vstream.h
balpar.o: balpar.c
balpar.o: check_arg.h
balpar.o: stringops.h
balpar.o: sys_defs.h
balpar.o: vbuf.h
balpar.o: vstring.h
base32_code.o: base32_code.c
base32_code.o: base32_code.h
base32_code.o: check_arg.h
base32_code.o: msg.h
base32_code.o: mymalloc.h
base32_code.o: sys_defs.h
base32_code.o: vbuf.h
base32_code.o: vstring.h
base64_code.o: base64_code.c
base64_code.o: base64_code.h
base64_code.o: check_arg.h
base64_code.o: msg.h
base64_code.o: mymalloc.h
base64_code.o: sys_defs.h
base64_code.o: vbuf.h
base64_code.o: vstring.h
basename.o: basename.c
basename.o: check_arg.h
basename.o: stringops.h
basename.o: sys_defs.h
basename.o: vbuf.h
basename.o: vstring.h
binhash.o: binhash.c
binhash.o: binhash.h
binhash.o: hash_fnv.h
binhash.o: msg.h
binhash.o: mymalloc.h
binhash.o: sys_defs.h
byte_mask.o: byte_mask.c
byte_mask.o: byte_mask.h
byte_mask.o: check_arg.h
byte_mask.o: msg.h
byte_mask.o: mymalloc.h
byte_mask.o: stringops.h
byte_mask.o: sys_defs.h
byte_mask.o: vbuf.h
byte_mask.o: vstring.h
casefold.o: casefold.c
casefold.o: check_arg.h
casefold.o: msg.h
casefold.o: stringops.h
casefold.o: sys_defs.h
casefold.o: vbuf.h
casefold.o: vstring.h
chroot_uid.o: chroot_uid.c
chroot_uid.o: chroot_uid.h
chroot_uid.o: msg.h
chroot_uid.o: sys_defs.h
cidr_match.o: check_arg.h
cidr_match.o: cidr_match.c
cidr_match.o: cidr_match.h
cidr_match.o: mask_addr.h
cidr_match.o: msg.h
cidr_match.o: myaddrinfo.h
cidr_match.o: split_at.h
cidr_match.o: stringops.h
cidr_match.o: sys_defs.h
cidr_match.o: vbuf.h
cidr_match.o: vstring.h
clean_ascii_cntrl_space.o: check_arg.h
clean_ascii_cntrl_space.o: clean_ascii_cntrl_space.c
clean_ascii_cntrl_space.o: clean_ascii_cntrl_space.h
clean_ascii_cntrl_space.o: stringops.h
clean_ascii_cntrl_space.o: sys_defs.h
clean_ascii_cntrl_space.o: vbuf.h
clean_ascii_cntrl_space.o: vstream.h
clean_ascii_cntrl_space.o: vstring.h
clean_env.o: argv.h
clean_env.o: check_arg.h
clean_env.o: clean_env.c
clean_env.o: clean_env.h
clean_env.o: msg.h
clean_env.o: mymalloc.h
clean_env.o: safe.h
clean_env.o: stringops.h
clean_env.o: sys_defs.h
clean_env.o: vbuf.h
clean_env.o: vstring.h
close_on_exec.o: close_on_exec.c
close_on_exec.o: iostuff.h
close_on_exec.o: msg.h
close_on_exec.o: sys_defs.h
concatenate.o: check_arg.h
concatenate.o: compat_va_copy.h
concatenate.o: concatenate.c
concatenate.o: mymalloc.h
concatenate.o: stringops.h
concatenate.o: sys_defs.h
concatenate.o: vbuf.h
concatenate.o: vstring.h
ctable.o: ctable.c
ctable.o: ctable.h
ctable.o: htable.h
ctable.o: msg.h
ctable.o: mymalloc.h
ctable.o: ring.h
ctable.o: sys_defs.h
dict.o: argv.h
dict.o: check_arg.h
dict.o: dict.c
dict.o: dict.h
dict.o: dict_ht.h
dict.o: htable.h
dict.o: iostuff.h
dict.o: line_number.h
dict.o: mac_expand.h
dict.o: mac_parse.h
dict.o: msg.h
dict.o: myflock.h
dict.o: mymalloc.h
dict.o: name_mask.h
dict.o: readlline.h
dict.o: stringops.h
dict.o: sys_defs.h
dict.o: vbuf.h
dict.o: vstream.h
dict.o: vstring.h
dict.o: warn_stat.h
dict_alloc.o: argv.h
dict_alloc.o: check_arg.h
dict_alloc.o: dict.h
dict_alloc.o: dict_alloc.c
dict_alloc.o: msg.h
dict_alloc.o: myflock.h
dict_alloc.o: mymalloc.h
dict_alloc.o: sys_defs.h
dict_alloc.o: vbuf.h
dict_alloc.o: vstream.h
dict_alloc.o: vstring.h
dict_cache.o: argv.h
dict_cache.o: check_arg.h
dict_cache.o: dict.h
dict_cache.o: dict_cache.c
dict_cache.o: dict_cache.h
dict_cache.o: events.h
dict_cache.o: msg.h
dict_cache.o: myflock.h
dict_cache.o: mymalloc.h
dict_cache.o: sys_defs.h
dict_cache.o: vbuf.h
dict_cache.o: vstream.h
dict_cache.o: vstring.h
dict_cdb.o: argv.h
dict_cdb.o: check_arg.h
dict_cdb.o: dict.h
dict_cdb.o: dict_cdb.c
dict_cdb.o: dict_cdb.h
dict_cdb.o: iostuff.h
dict_cdb.o: mkmap.h
dict_cdb.o: msg.h
dict_cdb.o: myflock.h
dict_cdb.o: mymalloc.h
dict_cdb.o: stringops.h
dict_cdb.o: sys_defs.h
dict_cdb.o: vbuf.h
dict_cdb.o: vstream.h
dict_cdb.o: vstring.h
dict_cdb.o: warn_stat.h
dict_cidr.o: argv.h
dict_cidr.o: check_arg.h
dict_cidr.o: cidr_match.h
dict_cidr.o: dict.h
dict_cidr.o: dict_cidr.c
dict_cidr.o: dict_cidr.h
dict_cidr.o: msg.h
dict_cidr.o: mvect.h
dict_cidr.o: myaddrinfo.h
dict_cidr.o: myflock.h
dict_cidr.o: mymalloc.h
dict_cidr.o: readlline.h
dict_cidr.o: stringops.h
dict_cidr.o: sys_defs.h
dict_cidr.o: vbuf.h
dict_cidr.o: vstream.h
dict_cidr.o: vstring.h
dict_cidr.o: warn_stat.h
dict_db.o: argv.h
dict_db.o: check_arg.h
dict_db.o: dict.h
dict_db.o: dict_db.c
dict_db.o: dict_db.h
dict_db.o: iostuff.h
dict_db.o: mkmap.h
dict_db.o: msg.h
dict_db.o: myflock.h
dict_db.o: mymalloc.h
dict_db.o: stringops.h
dict_db.o: sys_defs.h
dict_db.o: vbuf.h
dict_db.o: vstream.h
dict_db.o: vstring.h
dict_db.o: warn_stat.h
dict_dbm.o: dict_dbm.c
dict_dbm.o: sys_defs.h
dict_debug.o: argv.h
dict_debug.o: check_arg.h
dict_debug.o: dict.h
dict_debug.o: dict_debug.c
dict_debug.o: dict_debug.h
dict_debug.o: msg.h
dict_debug.o: myflock.h
dict_debug.o: mymalloc.h
dict_debug.o: sys_defs.h
dict_debug.o: vbuf.h
dict_debug.o: vstream.h
dict_debug.o: vstring.h
dict_env.o: argv.h
dict_env.o: check_arg.h
dict_env.o: dict.h
dict_env.o: dict_env.c
dict_env.o: dict_env.h
dict_env.o: msg.h
dict_env.o: myflock.h
dict_env.o: mymalloc.h
dict_env.o: safe.h
dict_env.o: stringops.h
dict_env.o: sys_defs.h
dict_env.o: vbuf.h
dict_env.o: vstream.h
dict_env.o: vstring.h
dict_fail.o: argv.h
dict_fail.o: check_arg.h
dict_fail.o: dict.h
dict_fail.o: dict_fail.c
dict_fail.o: dict_fail.h
dict_fail.o: mkmap.h
dict_fail.o: msg.h
dict_fail.o: myflock.h
dict_fail.o: mymalloc.h
dict_fail.o: sys_defs.h
dict_fail.o: vbuf.h
dict_fail.o: vstream.h
dict_fail.o: vstring.h
dict_file.o: argv.h
dict_file.o: base64_code.h
dict_file.o: check_arg.h
dict_file.o: dict.h
dict_file.o: dict_file.c
dict_file.o: msg.h
dict_file.o: myflock.h
dict_file.o: mymalloc.h
dict_file.o: sys_defs.h
dict_file.o: vbuf.h
dict_file.o: vstream.h
dict_file.o: vstring.h
dict_ht.o: argv.h
dict_ht.o: check_arg.h
dict_ht.o: dict.h
dict_ht.o: dict_ht.c
dict_ht.o: dict_ht.h
dict_ht.o: htable.h
dict_ht.o: myflock.h
dict_ht.o: mymalloc.h
dict_ht.o: stringops.h
dict_ht.o: sys_defs.h
dict_ht.o: vbuf.h
dict_ht.o: vstream.h
dict_ht.o: vstring.h
dict_inline.o: argv.h
dict_inline.o: check_arg.h
dict_inline.o: dict.h
dict_inline.o: dict_ht.h
dict_inline.o: dict_inline.c
dict_inline.o: dict_inline.h
dict_inline.o: htable.h
dict_inline.o: msg.h
dict_inline.o: myflock.h
dict_inline.o: mymalloc.h
dict_inline.o: stringops.h
dict_inline.o: sys_defs.h
dict_inline.o: vbuf.h
dict_inline.o: vstream.h
dict_inline.o: vstring.h
dict_lmdb.o: argv.h
dict_lmdb.o: check_arg.h
dict_lmdb.o: dict.h
dict_lmdb.o: dict_lmdb.c
dict_lmdb.o: dict_lmdb.h
dict_lmdb.o: htable.h
dict_lmdb.o: iostuff.h
dict_lmdb.o: mkmap.h
dict_lmdb.o: msg.h
dict_lmdb.o: myflock.h
dict_lmdb.o: mymalloc.h
dict_lmdb.o: slmdb.h
dict_lmdb.o: stringops.h
dict_lmdb.o: sys_defs.h
dict_lmdb.o: vbuf.h
dict_lmdb.o: vstream.h
dict_lmdb.o: vstring.h
dict_lmdb.o: warn_stat.h
dict_ni.o: dict_ni.c
dict_ni.o: sys_defs.h
dict_nis.o: argv.h
dict_nis.o: check_arg.h
dict_nis.o: dict.h
dict_nis.o: dict_nis.c
dict_nis.o: dict_nis.h
dict_nis.o: msg.h
dict_nis.o: myflock.h
dict_nis.o: mymalloc.h
dict_nis.o: stringops.h
dict_nis.o: sys_defs.h
dict_nis.o: vbuf.h
dict_nis.o: vstream.h
dict_nis.o: vstring.h
dict_nisplus.o: argv.h
dict_nisplus.o: check_arg.h
dict_nisplus.o: dict.h
dict_nisplus.o: dict_nisplus.c
dict_nisplus.o: dict_nisplus.h
dict_nisplus.o: msg.h
dict_nisplus.o: myflock.h
dict_nisplus.o: mymalloc.h
dict_nisplus.o: stringops.h
dict_nisplus.o: sys_defs.h
dict_nisplus.o: vbuf.h
dict_nisplus.o: vstream.h
dict_nisplus.o: vstring.h
dict_open.o: argv.h
dict_open.o: check_arg.h
dict_open.o: dict.h
dict_open.o: dict_cdb.h
dict_open.o: dict_cidr.h
dict_open.o: dict_db.h
dict_open.o: dict_dbm.h
dict_open.o: dict_debug.h
dict_open.o: dict_env.h
dict_open.o: dict_fail.h
dict_open.o: dict_ht.h
dict_open.o: dict_inline.h
dict_open.o: dict_lmdb.h
dict_open.o: dict_ni.h
dict_open.o: dict_nis.h
dict_open.o: dict_nisplus.h
dict_open.o: dict_open.c
dict_open.o: dict_pcre.h
dict_open.o: dict_pipe.h
dict_open.o: dict_random.h
dict_open.o: dict_regexp.h
dict_open.o: dict_sdbm.h
dict_open.o: dict_sockmap.h
dict_open.o: dict_static.h
dict_open.o: dict_tcp.h
dict_open.o: dict_thash.h
dict_open.o: dict_union.h
dict_open.o: dict_unix.h
dict_open.o: htable.h
dict_open.o: mkmap.h
dict_open.o: msg.h
dict_open.o: myflock.h
dict_open.o: mymalloc.h
dict_open.o: split_at.h
dict_open.o: stringops.h
dict_open.o: sys_defs.h
dict_open.o: vbuf.h
dict_open.o: vstream.h
dict_open.o: vstring.h
dict_pcre.o: argv.h
dict_pcre.o: check_arg.h
dict_pcre.o: dict.h
dict_pcre.o: dict_pcre.c
dict_pcre.o: dict_pcre.h
dict_pcre.o: mac_parse.h
dict_pcre.o: msg.h
dict_pcre.o: mvect.h
dict_pcre.o: myflock.h
dict_pcre.o: mymalloc.h
dict_pcre.o: readlline.h
dict_pcre.o: safe.h
dict_pcre.o: stringops.h
dict_pcre.o: sys_defs.h
dict_pcre.o: vbuf.h
dict_pcre.o: vstream.h
dict_pcre.o: vstring.h
dict_pcre.o: warn_stat.h
dict_pipe.o: argv.h
dict_pipe.o: check_arg.h
dict_pipe.o: dict.h
dict_pipe.o: dict_pipe.c
dict_pipe.o: dict_pipe.h
dict_pipe.o: htable.h
dict_pipe.o: msg.h
dict_pipe.o: myflock.h
dict_pipe.o: mymalloc.h
dict_pipe.o: stringops.h
dict_pipe.o: sys_defs.h
dict_pipe.o: vbuf.h
dict_pipe.o: vstream.h
dict_pipe.o: vstring.h
dict_pipe_test.o: ../../include/dict_test_helper.h
dict_pipe_test.o: argv.h
dict_pipe_test.o: check_arg.h
dict_pipe_test.o: dict.h
dict_pipe_test.o: dict_pipe.h
dict_pipe_test.o: dict_pipe_test.c
dict_pipe_test.o: msg.h
dict_pipe_test.o: msg_vstream.h
dict_pipe_test.o: myflock.h
dict_pipe_test.o: stringops.h
dict_pipe_test.o: sys_defs.h
dict_pipe_test.o: vbuf.h
dict_pipe_test.o: vstream.h
dict_pipe_test.o: vstring.h
dict_random.o: argv.h
dict_random.o: check_arg.h
dict_random.o: dict.h
dict_random.o: dict_random.c
dict_random.o: dict_random.h
dict_random.o: msg.h
dict_random.o: myflock.h
dict_random.o: mymalloc.h
dict_random.o: myrand.h
dict_random.o: stringops.h
dict_random.o: sys_defs.h
dict_random.o: vbuf.h
dict_random.o: vstream.h
dict_random.o: vstring.h
dict_regexp.o: argv.h
dict_regexp.o: check_arg.h
dict_regexp.o: dict.h
dict_regexp.o: dict_regexp.c
dict_regexp.o: dict_regexp.h
dict_regexp.o: mac_parse.h
dict_regexp.o: msg.h
dict_regexp.o: mvect.h
dict_regexp.o: myflock.h
dict_regexp.o: mymalloc.h
dict_regexp.o: readlline.h
dict_regexp.o: safe.h
dict_regexp.o: stringops.h
dict_regexp.o: sys_defs.h
dict_regexp.o: vbuf.h
dict_regexp.o: vstream.h
dict_regexp.o: vstring.h
dict_regexp.o: warn_stat.h
dict_sdbm.o: argv.h
dict_sdbm.o: check_arg.h
dict_sdbm.o: dict.h
dict_sdbm.o: dict_sdbm.c
dict_sdbm.o: dict_sdbm.h
dict_sdbm.o: htable.h
dict_sdbm.o: iostuff.h
dict_sdbm.o: mkmap.h
dict_sdbm.o: msg.h
dict_sdbm.o: myflock.h
dict_sdbm.o: mymalloc.h
dict_sdbm.o: stringops.h
dict_sdbm.o: sys_defs.h
dict_sdbm.o: vbuf.h
dict_sdbm.o: vstream.h
dict_sdbm.o: vstring.h
dict_sdbm.o: warn_stat.h
dict_sockmap.o: argv.h
dict_sockmap.o: auto_clnt.h
dict_sockmap.o: check_arg.h
dict_sockmap.o: dict.h
dict_sockmap.o: dict_sockmap.c
dict_sockmap.o: dict_sockmap.h
dict_sockmap.o: htable.h
dict_sockmap.o: msg.h
dict_sockmap.o: myflock.h
dict_sockmap.o: mymalloc.h
dict_sockmap.o: netstring.h
dict_sockmap.o: split_at.h
dict_sockmap.o: stringops.h
dict_sockmap.o: sys_defs.h
dict_sockmap.o: vbuf.h
dict_sockmap.o: vstream.h
dict_sockmap.o: vstring.h
dict_static.o: argv.h
dict_static.o: check_arg.h
dict_static.o: dict.h
dict_static.o: dict_static.c
dict_static.o: dict_static.h
dict_static.o: msg.h
dict_static.o: myflock.h
dict_static.o: mymalloc.h
dict_static.o: stringops.h
dict_static.o: sys_defs.h
dict_static.o: vbuf.h
dict_static.o: vstream.h
dict_static.o: vstring.h
dict_stream.o: argv.h
dict_stream.o: check_arg.h
dict_stream.o: dict.h
dict_stream.o: dict_stream.c
dict_stream.o: msg.h
dict_stream.o: myflock.h
dict_stream.o: mymalloc.h
dict_stream.o: stringops.h
dict_stream.o: sys_defs.h
dict_stream.o: vbuf.h
dict_stream.o: vstream.h
dict_stream.o: vstring.h
dict_surrogate.o: argv.h
dict_surrogate.o: check_arg.h
dict_surrogate.o: compat_va_copy.h
dict_surrogate.o: dict.h
dict_surrogate.o: dict_surrogate.c
dict_surrogate.o: msg.h
dict_surrogate.o: myflock.h
dict_surrogate.o: mymalloc.h
dict_surrogate.o: sys_defs.h
dict_surrogate.o: vbuf.h
dict_surrogate.o: vstream.h
dict_surrogate.o: vstring.h
dict_tcp.o: argv.h
dict_tcp.o: check_arg.h
dict_tcp.o: connect.h
dict_tcp.o: dict.h
dict_tcp.o: dict_tcp.c
dict_tcp.o: dict_tcp.h
dict_tcp.o: hex_quote.h
dict_tcp.o: iostuff.h
dict_tcp.o: msg.h
dict_tcp.o: myflock.h
dict_tcp.o: mymalloc.h
dict_tcp.o: stringops.h
dict_tcp.o: sys_defs.h
dict_tcp.o: vbuf.h
dict_tcp.o: vstream.h
dict_tcp.o: vstring.h
dict_tcp.o: vstring_vstream.h
dict_test.o: argv.h
dict_test.o: check_arg.h
dict_test.o: dict.h
dict_test.o: dict_db.h
dict_test.o: dict_lmdb.h
dict_test.o: dict_test.c
dict_test.o: mkmap.h
dict_test.o: msg.h
dict_test.o: msg_vstream.h
dict_test.o: myflock.h
dict_test.o: stringops.h
dict_test.o: sys_defs.h
dict_test.o: vbuf.h
dict_test.o: vstream.h
dict_test.o: vstring.h
dict_test.o: vstring_vstream.h
dict_thash.o: argv.h
dict_thash.o: check_arg.h
dict_thash.o: dict.h
dict_thash.o: dict_ht.h
dict_thash.o: dict_thash.c
dict_thash.o: dict_thash.h
dict_thash.o: htable.h
dict_thash.o: iostuff.h
dict_thash.o: msg.h
dict_thash.o: myflock.h
dict_thash.o: mymalloc.h
dict_thash.o: readlline.h
dict_thash.o: stringops.h
dict_thash.o: sys_defs.h
dict_thash.o: vbuf.h
dict_thash.o: vstream.h
dict_thash.o: vstring.h
dict_union.o: argv.h
dict_union.o: check_arg.h
dict_union.o: dict.h
dict_union.o: dict_union.c
dict_union.o: dict_union.h
dict_union.o: htable.h
dict_union.o: msg.h
dict_union.o: myflock.h
dict_union.o: mymalloc.h
dict_union.o: stringops.h
dict_union.o: sys_defs.h
dict_union.o: vbuf.h
dict_union.o: vstream.h
dict_union.o: vstring.h
dict_union_test.o: ../../include/dict_test_helper.h
dict_union_test.o: argv.h
dict_union_test.o: check_arg.h
dict_union_test.o: dict.h
dict_union_test.o: dict_union.h
dict_union_test.o: dict_union_test.c
dict_union_test.o: msg.h
dict_union_test.o: msg_vstream.h
dict_union_test.o: myflock.h
dict_union_test.o: stringops.h
dict_union_test.o: sys_defs.h
dict_union_test.o: vbuf.h
dict_union_test.o: vstream.h
dict_union_test.o: vstring.h
dict_unix.o: argv.h
dict_unix.o: check_arg.h
dict_unix.o: dict.h
dict_unix.o: dict_unix.c
dict_unix.o: dict_unix.h
dict_unix.o: msg.h
dict_unix.o: myflock.h
dict_unix.o: mymalloc.h
dict_unix.o: stringops.h
dict_unix.o: sys_defs.h
dict_unix.o: vbuf.h
dict_unix.o: vstream.h
dict_unix.o: vstring.h
dict_utf8.o: argv.h
dict_utf8.o: check_arg.h
dict_utf8.o: dict.h
dict_utf8.o: dict_utf8.c
dict_utf8.o: msg.h
dict_utf8.o: myflock.h
dict_utf8.o: mymalloc.h
dict_utf8.o: stringops.h
dict_utf8.o: sys_defs.h
dict_utf8.o: vbuf.h
dict_utf8.o: vstream.h
dict_utf8.o: vstring.h
dir_forest.o: check_arg.h
dir_forest.o: dir_forest.c
dir_forest.o: dir_forest.h
dir_forest.o: msg.h
dir_forest.o: sys_defs.h
dir_forest.o: vbuf.h
dir_forest.o: vstring.h
doze.o: doze.c
doze.o: iostuff.h
doze.o: msg.h
doze.o: sys_defs.h
dummy_read.o: dummy_read.c
dummy_read.o: iostuff.h
dummy_read.o: msg.h
dummy_read.o: sys_defs.h
dummy_write.o: dummy_write.c
dummy_write.o: iostuff.h
dummy_write.o: msg.h
dummy_write.o: sys_defs.h
dup2_pass_on_exec.o: dup2_pass_on_exec.c
duplex_pipe.o: duplex_pipe.c
duplex_pipe.o: iostuff.h
duplex_pipe.o: sane_socketpair.h
duplex_pipe.o: sys_defs.h
edit_file.o: check_arg.h
edit_file.o: edit_file.c
edit_file.o: edit_file.h
edit_file.o: msg.h
edit_file.o: myflock.h
edit_file.o: mymalloc.h
edit_file.o: stringops.h
edit_file.o: sys_defs.h
edit_file.o: vbuf.h
edit_file.o: vstream.h
edit_file.o: vstring.h
edit_file.o: warn_stat.h
environ.o: environ.c
environ.o: sys_defs.h
events.o: events.c
events.o: events.h
events.o: iostuff.h
events.o: msg.h
events.o: mymalloc.h
events.o: ring.h
events.o: sys_defs.h
exec_command.o: argv.h
exec_command.o: exec_command.c
exec_command.o: exec_command.h
exec_command.o: msg.h
exec_command.o: sys_defs.h
extpar.o: check_arg.h
extpar.o: extpar.c
extpar.o: stringops.h
extpar.o: sys_defs.h
extpar.o: vbuf.h
extpar.o: vstring.h
fifo_listen.o: fifo_listen.c
fifo_listen.o: htable.h
fifo_listen.o: iostuff.h
fifo_listen.o: listen.h
fifo_listen.o: msg.h
fifo_listen.o: sys_defs.h
fifo_listen.o: warn_stat.h
fifo_open.o: fifo_open.c
fifo_rdonly_bug.o: fifo_rdonly_bug.c
fifo_rdonly_bug.o: sys_defs.h
fifo_rdwr_bug.o: fifo_rdwr_bug.c
fifo_rdwr_bug.o: sys_defs.h
fifo_trigger.o: check_arg.h
fifo_trigger.o: fifo_trigger.c
fifo_trigger.o: iostuff.h
fifo_trigger.o: msg.h
fifo_trigger.o: safe_open.h
fifo_trigger.o: sys_defs.h
fifo_trigger.o: trigger.h
fifo_trigger.o: vbuf.h
fifo_trigger.o: vstream.h
fifo_trigger.o: vstring.h
file_limit.o: file_limit.c
file_limit.o: iostuff.h
file_limit.o: msg.h
file_limit.o: sys_defs.h
find_inet.o: check_arg.h
find_inet.o: find_inet.c
find_inet.o: find_inet.h
find_inet.o: known_tcp_ports.h
find_inet.o: msg.h
find_inet.o: stringops.h
find_inet.o: sys_defs.h
find_inet.o: vbuf.h
find_inet.o: vstring.h
format_tv.o: check_arg.h
format_tv.o: format_tv.c
format_tv.o: format_tv.h
format_tv.o: msg.h
format_tv.o: sys_defs.h
format_tv.o: vbuf.h
format_tv.o: vstring.h
fsspace.o: fsspace.c
fsspace.o: fsspace.h
fsspace.o: msg.h
fsspace.o: sys_defs.h
fullname.o: check_arg.h
fullname.o: fullname.c
fullname.o: fullname.h
fullname.o: safe.h
fullname.o: sys_defs.h
fullname.o: vbuf.h
fullname.o: vstring.h
gccw.o: gccw.c
get_domainname.o: get_domainname.c
get_domainname.o: get_domainname.h
get_domainname.o: get_hostname.h
get_domainname.o: mymalloc.h
get_domainname.o: sys_defs.h
get_hostname.o: get_hostname.c
get_hostname.o: get_hostname.h
get_hostname.o: msg.h
get_hostname.o: mymalloc.h
get_hostname.o: sys_defs.h
get_hostname.o: valid_hostname.h
hash_fnv.o: hash_fnv.c
hash_fnv.o: hash_fnv.h
hash_fnv.o: ldseed.h
hash_fnv.o: msg.h
hash_fnv.o: sys_defs.h
hash_fnv_test.o: check_arg.h
hash_fnv_test.o: hash_fnv.h
hash_fnv_test.o: hash_fnv_test.c
hash_fnv_test.o: msg.h
hash_fnv_test.o: msg_vstream.h
hash_fnv_test.o: stringops.h
hash_fnv_test.o: sys_defs.h
hash_fnv_test.o: vbuf.h
hash_fnv_test.o: vstream.h
hash_fnv_test.o: vstring.h
hex_code.o: check_arg.h
hex_code.o: hex_code.c
hex_code.o: hex_code.h
hex_code.o: msg.h
hex_code.o: mymalloc.h
hex_code.o: sys_defs.h
hex_code.o: vbuf.h
hex_code.o: vstring.h
hex_quote.o: check_arg.h
hex_quote.o: hex_quote.c
hex_quote.o: hex_quote.h
hex_quote.o: msg.h
hex_quote.o: sys_defs.h
hex_quote.o: vbuf.h
hex_quote.o: vstring.h
host_port.o: check_arg.h
host_port.o: host_port.c
host_port.o: host_port.h
host_port.o: msg.h
host_port.o: split_at.h
host_port.o: stringops.h
host_port.o: sys_defs.h
host_port.o: valid_hostname.h
host_port.o: valid_utf8_hostname.h
host_port.o: vbuf.h
host_port.o: vstring.h
htable.o: hash_fnv.h
htable.o: htable.c
htable.o: htable.h
htable.o: msg.h
htable.o: mymalloc.h
htable.o: sys_defs.h
inet_addr_host.o: inet_addr_host.c
inet_addr_host.o: inet_addr_host.h
inet_addr_host.o: inet_addr_list.h
inet_addr_host.o: inet_proto.h
inet_addr_host.o: msg.h
inet_addr_host.o: myaddrinfo.h
inet_addr_host.o: mymalloc.h
inet_addr_host.o: sock_addr.h
inet_addr_host.o: sys_defs.h
inet_addr_list.o: inet_addr_list.c
inet_addr_list.o: inet_addr_list.h
inet_addr_list.o: msg.h
inet_addr_list.o: myaddrinfo.h
inet_addr_list.o: mymalloc.h
inet_addr_list.o: sock_addr.h
inet_addr_list.o: sys_defs.h
inet_addr_local.o: check_arg.h
inet_addr_local.o: hex_code.h
inet_addr_local.o: inet_addr_list.h
inet_addr_local.o: inet_addr_local.c
inet_addr_local.o: inet_addr_local.h
inet_addr_local.o: mask_addr.h
inet_addr_local.o: msg.h
inet_addr_local.o: myaddrinfo.h
inet_addr_local.o: mymalloc.h
inet_addr_local.o: sock_addr.h
inet_addr_local.o: sys_defs.h
inet_addr_local.o: vbuf.h
inet_addr_local.o: vstring.h
inet_addr_sizes.o: inet_addr_sizes.c
inet_addr_sizes.o: inet_addr_sizes.h
inet_addr_sizes.o: msg.h
inet_addr_sizes.o: myaddrinfo.h
inet_addr_sizes.o: sys_defs.h
inet_connect.o: connect.h
inet_connect.o: host_port.h
inet_connect.o: inet_connect.c
inet_connect.o: inet_proto.h
inet_connect.o: iostuff.h
inet_connect.o: msg.h
inet_connect.o: myaddrinfo.h
inet_connect.o: mymalloc.h
inet_connect.o: sane_connect.h
inet_connect.o: sock_addr.h
inet_connect.o: sys_defs.h
inet_connect.o: timed_connect.h
inet_listen.o: host_port.h
inet_listen.o: htable.h
inet_listen.o: inet_listen.c
inet_listen.o: inet_proto.h
inet_listen.o: iostuff.h
inet_listen.o: listen.h
inet_listen.o: msg.h
inet_listen.o: myaddrinfo.h
inet_listen.o: mymalloc.h
inet_listen.o: sane_accept.h
inet_listen.o: sock_addr.h
inet_listen.o: sys_defs.h
inet_prefix_top.o: check_arg.h
inet_prefix_top.o: inet_addr_sizes.h
inet_prefix_top.o: inet_prefix_top.c
inet_prefix_top.o: inet_prefix_top.h
inet_prefix_top.o: mask_addr.h
inet_prefix_top.o: msg.h
inet_prefix_top.o: sys_defs.h
inet_prefix_top.o: vbuf.h
inet_prefix_top.o: vstring.h
inet_proto.o: check_arg.h
inet_proto.o: inet_proto.c
inet_proto.o: inet_proto.h
inet_proto.o: msg.h
inet_proto.o: myaddrinfo.h
inet_proto.o: mymalloc.h
inet_proto.o: name_mask.h
inet_proto.o: sys_defs.h
inet_proto.o: vbuf.h
inet_proto.o: vstring.h
inet_trigger.o: connect.h
inet_trigger.o: events.h
inet_trigger.o: inet_trigger.c
inet_trigger.o: iostuff.h
inet_trigger.o: msg.h
inet_trigger.o: mymalloc.h
inet_trigger.o: sys_defs.h
inet_trigger.o: trigger.h
inet_windowsize.o: inet_windowsize.c
inet_windowsize.o: iostuff.h
inet_windowsize.o: msg.h
inet_windowsize.o: sys_defs.h
ip_match.o: check_arg.h
ip_match.o: ip_match.c
ip_match.o: ip_match.h
ip_match.o: msg.h
ip_match.o: mymalloc.h
ip_match.o: sys_defs.h
ip_match.o: vbuf.h
ip_match.o: vstring.h
killme_after.o: killme_after.c
killme_after.o: killme_after.h
killme_after.o: sys_defs.h
known_tcp_ports.o: check_arg.h
known_tcp_ports.o: htable.h
known_tcp_ports.o: known_tcp_ports.c
known_tcp_ports.o: known_tcp_ports.h
known_tcp_ports.o: mymalloc.h
known_tcp_ports.o: stringops.h
known_tcp_ports.o: sys_defs.h
known_tcp_ports.o: vbuf.h
known_tcp_ports.o: vstring.h
ldseed.o: iostuff.h
ldseed.o: ldseed.c
ldseed.o: ldseed.h
ldseed.o: msg.h
ldseed.o: sys_defs.h
line_number.o: check_arg.h
line_number.o: line_number.c
line_number.o: line_number.h
line_number.o: sys_defs.h
line_number.o: vbuf.h
line_number.o: vstring.h
line_wrap.o: line_wrap.c
line_wrap.o: line_wrap.h
line_wrap.o: sys_defs.h
load_file.o: check_arg.h
load_file.o: iostuff.h
load_file.o: load_file.c
load_file.o: load_file.h
load_file.o: msg.h
load_file.o: sys_defs.h
load_file.o: vbuf.h
load_file.o: vstream.h
load_file.o: warn_stat.h
load_lib.o: load_lib.c
load_lib.o: load_lib.h
load_lib.o: msg.h
load_lib.o: sys_defs.h
logwriter.o: check_arg.h
logwriter.o: iostuff.h
logwriter.o: logwriter.c
logwriter.o: logwriter.h
logwriter.o: msg.h
logwriter.o: mymalloc.h
logwriter.o: name_code.h
logwriter.o: safe_open.h
logwriter.o: sys_defs.h
logwriter.o: vbuf.h
logwriter.o: vstream.h
logwriter.o: vstring.h
lowercase.o: check_arg.h
lowercase.o: lowercase.c
lowercase.o: stringops.h
lowercase.o: sys_defs.h
lowercase.o: vbuf.h
lowercase.o: vstring.h
lstat_as.o: lstat_as.c
lstat_as.o: lstat_as.h
lstat_as.o: msg.h
lstat_as.o: set_eugid.h
lstat_as.o: sys_defs.h
lstat_as.o: warn_stat.h
mac_expand.o: check_arg.h
mac_expand.o: htable.h
mac_expand.o: mac_expand.c
mac_expand.o: mac_expand.h
mac_expand.o: mac_parse.h
mac_expand.o: msg.h
mac_expand.o: mymalloc.h
mac_expand.o: name_code.h
mac_expand.o: sane_strtol.h
mac_expand.o: stringops.h
mac_expand.o: sys_defs.h
mac_expand.o: vbuf.h
mac_expand.o: vstring.h
mac_midna.o: check_arg.h
mac_midna.o: mac_expand.h
mac_midna.o: mac_midna.c
mac_midna.o: mac_midna.h
mac_midna.o: mac_parse.h
mac_midna.o: midna_domain.h
mac_midna.o: msg.h
mac_midna.o: stringops.h
mac_midna.o: sys_defs.h
mac_midna.o: vbuf.h
mac_midna.o: vstring.h
mac_parse.o: check_arg.h
mac_parse.o: mac_parse.c
mac_parse.o: mac_parse.h
mac_parse.o: msg.h
mac_parse.o: sys_defs.h
mac_parse.o: vbuf.h
mac_parse.o: vstring.h
make_dirs.o: check_arg.h
make_dirs.o: make_dirs.c
make_dirs.o: make_dirs.h
make_dirs.o: msg.h
make_dirs.o: mymalloc.h
make_dirs.o: stringops.h
make_dirs.o: sys_defs.h
make_dirs.o: vbuf.h
make_dirs.o: vstring.h
make_dirs.o: warn_stat.h
mask_addr.o: mask_addr.c
mask_addr.o: mask_addr.h
mask_addr.o: msg.h
mask_addr.o: sys_defs.h
match_list.o: argv.h
match_list.o: check_arg.h
match_list.o: dict.h
match_list.o: match_list.c
match_list.o: match_list.h
match_list.o: msg.h
match_list.o: myflock.h
match_list.o: mymalloc.h
match_list.o: readlline.h
match_list.o: stringops.h
match_list.o: sys_defs.h
match_list.o: vbuf.h
match_list.o: vstream.h
match_list.o: vstring.h
match_ops.o: argv.h
match_ops.o: check_arg.h
match_ops.o: cidr_match.h
match_ops.o: dict.h
match_ops.o: match_list.h
match_ops.o: match_ops.c
match_ops.o: msg.h
match_ops.o: myaddrinfo.h
match_ops.o: myflock.h
match_ops.o: mymalloc.h
match_ops.o: split_at.h
match_ops.o: stringops.h
match_ops.o: sys_defs.h
match_ops.o: vbuf.h
match_ops.o: vstream.h
match_ops.o: vstring.h
midna_domain.o: check_arg.h
midna_domain.o: ctable.h
midna_domain.o: midna_domain.c
midna_domain.o: midna_domain.h
midna_domain.o: msg.h
midna_domain.o: mymalloc.h
midna_domain.o: name_mask.h
midna_domain.o: stringops.h
midna_domain.o: sys_defs.h
midna_domain.o: valid_hostname.h
midna_domain.o: vbuf.h
midna_domain.o: vstring.h
mkmap_cdb.o: argv.h
mkmap_cdb.o: check_arg.h
mkmap_cdb.o: dict.h
mkmap_cdb.o: dict_cdb.h
mkmap_cdb.o: mkmap.h
mkmap_cdb.o: mkmap_cdb.c
mkmap_cdb.o: myflock.h
mkmap_cdb.o: mymalloc.h
mkmap_cdb.o: sys_defs.h
mkmap_cdb.o: vbuf.h
mkmap_cdb.o: vstream.h
mkmap_cdb.o: vstring.h
mkmap_db.o: argv.h
mkmap_db.o: check_arg.h
mkmap_db.o: dict.h
mkmap_db.o: dict_db.h
mkmap_db.o: mkmap.h
mkmap_db.o: mkmap_db.c
mkmap_db.o: msg.h
mkmap_db.o: myflock.h
mkmap_db.o: mymalloc.h
mkmap_db.o: stringops.h
mkmap_db.o: sys_defs.h
mkmap_db.o: vbuf.h
mkmap_db.o: vstream.h
mkmap_db.o: vstring.h
mkmap_db.o: warn_stat.h
mkmap_dbm.o: argv.h
mkmap_dbm.o: check_arg.h
mkmap_dbm.o: dict.h
mkmap_dbm.o: dict_dbm.h
mkmap_dbm.o: mkmap.h
mkmap_dbm.o: mkmap_dbm.c
mkmap_dbm.o: msg.h
mkmap_dbm.o: myflock.h
mkmap_dbm.o: mymalloc.h
mkmap_dbm.o: stringops.h
mkmap_dbm.o: sys_defs.h
mkmap_dbm.o: vbuf.h
mkmap_dbm.o: vstream.h
mkmap_dbm.o: vstring.h
mkmap_fail.o: argv.h
mkmap_fail.o: check_arg.h
mkmap_fail.o: dict.h
mkmap_fail.o: dict_fail.h
mkmap_fail.o: mkmap.h
mkmap_fail.o: mkmap_fail.c
mkmap_fail.o: myflock.h
mkmap_fail.o: mymalloc.h
mkmap_fail.o: sys_defs.h
mkmap_fail.o: vbuf.h
mkmap_fail.o: vstream.h
mkmap_fail.o: vstring.h
mkmap_lmdb.o: argv.h
mkmap_lmdb.o: check_arg.h
mkmap_lmdb.o: dict.h
mkmap_lmdb.o: dict_lmdb.h
mkmap_lmdb.o: mkmap.h
mkmap_lmdb.o: mkmap_lmdb.c
mkmap_lmdb.o: myflock.h
mkmap_lmdb.o: mymalloc.h
mkmap_lmdb.o: sys_defs.h
mkmap_lmdb.o: vbuf.h
mkmap_lmdb.o: vstream.h
mkmap_lmdb.o: vstring.h
mkmap_open.o: argv.h
mkmap_open.o: check_arg.h
mkmap_open.o: dict.h
mkmap_open.o: mkmap.h
mkmap_open.o: mkmap_open.c
mkmap_open.o: msg.h
mkmap_open.o: myflock.h
mkmap_open.o: mymalloc.h
mkmap_open.o: sigdelay.h
mkmap_open.o: stringops.h
mkmap_open.o: sys_defs.h
mkmap_open.o: vbuf.h
mkmap_open.o: vstream.h
mkmap_open.o: vstring.h
mkmap_sdbm.o: argv.h
mkmap_sdbm.o: check_arg.h
mkmap_sdbm.o: dict.h
mkmap_sdbm.o: dict_sdbm.h
mkmap_sdbm.o: mkmap.h
mkmap_sdbm.o: mkmap_sdbm.c
mkmap_sdbm.o: msg.h
mkmap_sdbm.o: myflock.h
mkmap_sdbm.o: mymalloc.h
mkmap_sdbm.o: stringops.h
mkmap_sdbm.o: sys_defs.h
mkmap_sdbm.o: vbuf.h
mkmap_sdbm.o: vstream.h
mkmap_sdbm.o: vstring.h
msg.o: msg.c
msg.o: msg.h
msg.o: msg_output.h
msg.o: sys_defs.h
msg_logger.o: check_arg.h
msg_logger.o: connect.h
msg_logger.o: iostuff.h
msg_logger.o: logwriter.h
msg_logger.o: msg.h
msg_logger.o: msg_logger.c
msg_logger.o: msg_logger.h
msg_logger.o: msg_output.h
msg_logger.o: mymalloc.h
msg_logger.o: safe.h
msg_logger.o: sys_defs.h
msg_logger.o: vbuf.h
msg_logger.o: vstream.h
msg_logger.o: vstring.h
msg_output.o: check_arg.h
msg_output.o: msg_output.c
msg_output.o: msg_output.h
msg_output.o: msg_vstream.h
msg_output.o: mymalloc.h
msg_output.o: stringops.h
msg_output.o: sys_defs.h
msg_output.o: vbuf.h
msg_output.o: vstream.h
msg_output.o: vstring.h
msg_rate_delay.o: check_arg.h
msg_rate_delay.o: events.h
msg_rate_delay.o: msg.h
msg_rate_delay.o: msg_rate_delay.c
msg_rate_delay.o: sys_defs.h
msg_rate_delay.o: vbuf.h
msg_rate_delay.o: vstring.h
msg_syslog.o: check_arg.h
msg_syslog.o: msg.h
msg_syslog.o: msg_output.h
msg_syslog.o: msg_syslog.c
msg_syslog.o: msg_syslog.h
msg_syslog.o: mymalloc.h
msg_syslog.o: safe.h
msg_syslog.o: stringops.h
msg_syslog.o: sys_defs.h
msg_syslog.o: vbuf.h
msg_syslog.o: vstring.h
msg_vstream.o: check_arg.h
msg_vstream.o: msg.h
msg_vstream.o: msg_output.h
msg_vstream.o: msg_vstream.c
msg_vstream.o: msg_vstream.h
msg_vstream.o: sys_defs.h
msg_vstream.o: vbuf.h
msg_vstream.o: vstream.h
mvect.o: mvect.c
mvect.o: mvect.h
mvect.o: mymalloc.h
mvect.o: sys_defs.h
myaddrinfo.o: check_arg.h
myaddrinfo.o: inet_proto.h
myaddrinfo.o: known_tcp_ports.h
myaddrinfo.o: msg.h
myaddrinfo.o: myaddrinfo.c
myaddrinfo.o: myaddrinfo.h
myaddrinfo.o: mymalloc.h
myaddrinfo.o: sock_addr.h
myaddrinfo.o: split_at.h
myaddrinfo.o: stringops.h
myaddrinfo.o: sys_defs.h
myaddrinfo.o: valid_hostname.h
myaddrinfo.o: vbuf.h
myaddrinfo.o: vstring.h
myflock.o: check_arg.h
myflock.o: msg.h
myflock.o: myflock.c
myflock.o: myflock.h
myflock.o: name_mask.h
myflock.o: sys_defs.h
myflock.o: vbuf.h
myflock.o: vstring.h
mymalloc.o: msg.h
mymalloc.o: mymalloc.c
mymalloc.o: mymalloc.h
mymalloc.o: sys_defs.h
myrand.o: myrand.c
myrand.o: myrand.h
myrand.o: sys_defs.h
mystrerror.o: check_arg.h
mystrerror.o: mystrerror.c
mystrerror.o: stringops.h
mystrerror.o: sys_defs.h
mystrerror.o: vbuf.h
mystrerror.o: vstring.h
mystrtok.o: check_arg.h
mystrtok.o: msg.h
mystrtok.o: mystrtok.c
mystrtok.o: stringops.h
mystrtok.o: sys_defs.h
mystrtok.o: vbuf.h
mystrtok.o: vstring.h
name_code.o: name_code.c
name_code.o: name_code.h
name_code.o: sys_defs.h
name_mask.o: check_arg.h
name_mask.o: msg.h
name_mask.o: mymalloc.h
name_mask.o: name_mask.c
name_mask.o: name_mask.h
name_mask.o: stringops.h
name_mask.o: sys_defs.h
name_mask.o: vbuf.h
name_mask.o: vstring.h
nbbio.o: events.h
nbbio.o: msg.h
nbbio.o: mymalloc.h
nbbio.o: nbbio.c
nbbio.o: nbbio.h
nbbio.o: sys_defs.h
netstring.o: check_arg.h
netstring.o: compat_va_copy.h
netstring.o: msg.h
netstring.o: netstring.c
netstring.o: netstring.h
netstring.o: sys_defs.h
netstring.o: vbuf.h
netstring.o: vstream.h
netstring.o: vstring.h
neuter.o: check_arg.h
neuter.o: neuter.c
neuter.o: stringops.h
neuter.o: sys_defs.h
neuter.o: vbuf.h
neuter.o: vstring.h
non_blocking.o: iostuff.h
non_blocking.o: msg.h
non_blocking.o: non_blocking.c
non_blocking.o: sys_defs.h
normalize_v4mapped_addr.o: inet_proto.h
normalize_v4mapped_addr.o: myaddrinfo.h
normalize_v4mapped_addr.o: normalize_v4mapped_addr.c
normalize_v4mapped_addr.o: normalize_v4mapped_addr.h
normalize_v4mapped_addr.o: sock_addr.h
normalize_v4mapped_addr.o: sys_defs.h
normalize_v4mapped_addr_test.o: check_arg.h
normalize_v4mapped_addr_test.o: inet_proto.h
normalize_v4mapped_addr_test.o: msg.h
normalize_v4mapped_addr_test.o: msg_vstream.h
normalize_v4mapped_addr_test.o: myaddrinfo.h
normalize_v4mapped_addr_test.o: normalize_v4mapped_addr.h
normalize_v4mapped_addr_test.o: normalize_v4mapped_addr_test.c
normalize_v4mapped_addr_test.o: stringops.h
normalize_v4mapped_addr_test.o: sys_defs.h
normalize_v4mapped_addr_test.o: vbuf.h
normalize_v4mapped_addr_test.o: vstream.h
normalize_v4mapped_addr_test.o: vstring.h
normalize_ws.o: check_arg.h
normalize_ws.o: msg.h
normalize_ws.o: msg_vstream.h
normalize_ws.o: mymalloc.h
normalize_ws.o: normalize_ws.c
normalize_ws.o: stringops.h
normalize_ws.o: sys_defs.h
normalize_ws.o: vbuf.h
normalize_ws.o: vstream.h
normalize_ws.o: vstring.h
nvtable.o: htable.h
nvtable.o: mymalloc.h
nvtable.o: nvtable.c
nvtable.o: nvtable.h
nvtable.o: sys_defs.h
open_as.o: check_arg.h
open_as.o: msg.h
open_as.o: open_as.c
open_as.o: open_as.h
open_as.o: set_eugid.h
open_as.o: sys_defs.h
open_as.o: vbuf.h
open_as.o: vstream.h
open_limit.o: iostuff.h
open_limit.o: open_limit.c
open_limit.o: sys_defs.h
open_lock.o: check_arg.h
open_lock.o: msg.h
open_lock.o: myflock.h
open_lock.o: open_lock.c
open_lock.o: open_lock.h
open_lock.o: safe_open.h
open_lock.o: sys_defs.h
open_lock.o: vbuf.h
open_lock.o: vstream.h
open_lock.o: vstring.h
ossl_digest.o: argv.h
ossl_digest.o: check_arg.h
ossl_digest.o: msg.h
ossl_digest.o: mymalloc.h
ossl_digest.o: ossl_digest.c
ossl_digest.o: ossl_digest.h
ossl_digest.o: sys_defs.h
ossl_digest.o: vbuf.h
ossl_digest.o: vstring.h
ossl_digest_test.o: argv.h
ossl_digest_test.o: check_arg.h
ossl_digest_test.o: hex_code.h
ossl_digest_test.o: msg.h
ossl_digest_test.o: mymalloc.h
ossl_digest_test.o: ossl_digest.h
ossl_digest_test.o: ossl_digest_test.c
ossl_digest_test.o: stringops.h
ossl_digest_test.o: sys_defs.h
ossl_digest_test.o: vbuf.h
ossl_digest_test.o: vstring.h
pass_accept.o: attr.h
pass_accept.o: check_arg.h
pass_accept.o: htable.h
pass_accept.o: iostuff.h
pass_accept.o: listen.h
pass_accept.o: msg.h
pass_accept.o: mymalloc.h
pass_accept.o: nvtable.h
pass_accept.o: pass_accept.c
pass_accept.o: sys_defs.h
pass_accept.o: vbuf.h
pass_accept.o: vstream.h
pass_accept.o: vstring.h
pass_trigger.o: connect.h
pass_trigger.o: events.h
pass_trigger.o: iostuff.h
pass_trigger.o: msg.h
pass_trigger.o: mymalloc.h
pass_trigger.o: pass_trigger.c
pass_trigger.o: sys_defs.h
pass_trigger.o: trigger.h
peekfd.o: iostuff.h
peekfd.o: peekfd.c
peekfd.o: sys_defs.h
poll_fd.o: iostuff.h
poll_fd.o: msg.h
poll_fd.o: poll_fd.c
poll_fd.o: sys_defs.h
posix_signals.o: posix_signals.c
posix_signals.o: posix_signals.h
posix_signals.o: sys_defs.h
printable.o: check_arg.h
printable.o: parse_utf8_char.h
printable.o: printable.c
printable.o: stringops.h
printable.o: sys_defs.h
printable.o: vbuf.h
printable.o: vstring.h
quote_for_json.o: check_arg.h
quote_for_json.o: quote_for_json.c
quote_for_json.o: stringops.h
quote_for_json.o: sys_defs.h
quote_for_json.o: vbuf.h
quote_for_json.o: vstring.h
rand_sleep.o: iostuff.h
rand_sleep.o: msg.h
rand_sleep.o: myrand.h
rand_sleep.o: rand_sleep.c
rand_sleep.o: sys_defs.h
readlline.o: check_arg.h
readlline.o: msg.h
readlline.o: readlline.c
readlline.o: readlline.h
readlline.o: sys_defs.h
readlline.o: vbuf.h
readlline.o: vstream.h
readlline.o: vstring.h
recv_pass_attr.o: attr.h
recv_pass_attr.o: check_arg.h
recv_pass_attr.o: htable.h
recv_pass_attr.o: iostuff.h
recv_pass_attr.o: listen.h
recv_pass_attr.o: mymalloc.h
recv_pass_attr.o: nvtable.h
recv_pass_attr.o: recv_pass_attr.c
recv_pass_attr.o: sys_defs.h
recv_pass_attr.o: vbuf.h
recv_pass_attr.o: vstream.h
recv_pass_attr.o: vstring.h
ring.o: ring.c
ring.o: ring.h
safe_getenv.o: safe.h
safe_getenv.o: safe_getenv.c
safe_getenv.o: sys_defs.h
safe_open.o: check_arg.h
safe_open.o: msg.h
safe_open.o: safe_open.c
safe_open.o: safe_open.h
safe_open.o: stringops.h
safe_open.o: sys_defs.h
safe_open.o: vbuf.h
safe_open.o: vstream.h
safe_open.o: vstring.h
safe_open.o: warn_stat.h
sane_accept.o: msg.h
sane_accept.o: sane_accept.c
sane_accept.o: sane_accept.h
sane_accept.o: sys_defs.h
sane_basename.o: check_arg.h
sane_basename.o: sane_basename.c
sane_basename.o: stringops.h
sane_basename.o: sys_defs.h
sane_basename.o: vbuf.h
sane_basename.o: vstring.h
sane_connect.o: msg.h
sane_connect.o: sane_connect.c
sane_connect.o: sane_connect.h
sane_connect.o: sys_defs.h
sane_link.o: msg.h
sane_link.o: sane_fsops.h
sane_link.o: sane_link.c
sane_link.o: sys_defs.h
sane_link.o: warn_stat.h
sane_rename.o: msg.h
sane_rename.o: sane_fsops.h
sane_rename.o: sane_rename.c
sane_rename.o: sys_defs.h
sane_rename.o: warn_stat.h
sane_sockaddr_to_hostaddr.o: myaddrinfo.h
sane_sockaddr_to_hostaddr.o: normalize_v4mapped_addr.h
sane_sockaddr_to_hostaddr.o: sane_sockaddr_to_hostaddr.c
sane_sockaddr_to_hostaddr.o: sys_defs.h
sane_socketpair.o: msg.h
sane_socketpair.o: sane_socketpair.c
sane_socketpair.o: sane_socketpair.h
sane_socketpair.o: sys_defs.h
sane_strtol.o: sane_strtol.c
sane_strtol.o: sane_strtol.h
sane_strtol.o: sys_defs.h
sane_time.o: msg.h
sane_time.o: sane_time.c
sane_time.o: sane_time.h
sane_time.o: sys_defs.h
scan_dir.o: check_arg.h
scan_dir.o: msg.h
scan_dir.o: mymalloc.h
scan_dir.o: scan_dir.c
scan_dir.o: scan_dir.h
scan_dir.o: stringops.h
scan_dir.o: sys_defs.h
scan_dir.o: vbuf.h
scan_dir.o: vstring.h
select_bug.o: check_arg.h
select_bug.o: msg.h
select_bug.o: msg_vstream.h
select_bug.o: select_bug.c
select_bug.o: sys_defs.h
select_bug.o: vbuf.h
select_bug.o: vstream.h
set_eugid.o: msg.h
set_eugid.o: set_eugid.c
set_eugid.o: set_eugid.h
set_eugid.o: sys_defs.h
set_ugid.o: msg.h
set_ugid.o: set_ugid.c
set_ugid.o: set_ugid.h
set_ugid.o: sys_defs.h
sigdelay.o: msg.h
sigdelay.o: posix_signals.h
sigdelay.o: sigdelay.c
sigdelay.o: sigdelay.h
sigdelay.o: sys_defs.h
skipblanks.o: check_arg.h
skipblanks.o: skipblanks.c
skipblanks.o: stringops.h
skipblanks.o: sys_defs.h
skipblanks.o: vbuf.h
skipblanks.o: vstring.h
slmdb.o: check_arg.h
slmdb.o: slmdb.c
slmdb.o: slmdb.h
sock_addr.o: msg.h
sock_addr.o: sock_addr.c
sock_addr.o: sock_addr.h
sock_addr.o: sys_defs.h
spawn_command.o: argv.h
spawn_command.o: check_arg.h
spawn_command.o: clean_env.h
spawn_command.o: exec_command.h
spawn_command.o: msg.h
spawn_command.o: set_eugid.h
spawn_command.o: set_ugid.h
spawn_command.o: spawn_command.c
spawn_command.o: spawn_command.h
spawn_command.o: sys_defs.h
spawn_command.o: timed_wait.h
split_at.o: split_at.c
split_at.o: split_at.h
split_at.o: sys_defs.h
split_nameval.o: check_arg.h
split_nameval.o: msg.h
split_nameval.o: split_nameval.c
split_nameval.o: stringops.h
split_nameval.o: sys_defs.h
split_nameval.o: vbuf.h
split_nameval.o: vstring.h
split_qnameval.o: check_arg.h
split_qnameval.o: msg.h
split_qnameval.o: split_qnameval.c
split_qnameval.o: stringops.h
split_qnameval.o: sys_defs.h
split_qnameval.o: vbuf.h
split_qnameval.o: vstring.h
stat_as.o: msg.h
stat_as.o: set_eugid.h
stat_as.o: stat_as.c
stat_as.o: stat_as.h
stat_as.o: sys_defs.h
stat_as.o: warn_stat.h
strcasecmp.o: strcasecmp.c
strcasecmp.o: sys_defs.h
strcasecmp_utf8.o: check_arg.h
strcasecmp_utf8.o: strcasecmp_utf8.c
strcasecmp_utf8.o: stringops.h
strcasecmp_utf8.o: sys_defs.h
strcasecmp_utf8.o: vbuf.h
strcasecmp_utf8.o: vstring.h
stream_connect.o: connect.h
stream_connect.o: iostuff.h
stream_connect.o: msg.h
stream_connect.o: stream_connect.c
stream_connect.o: sys_defs.h
stream_listen.o: htable.h
stream_listen.o: iostuff.h
stream_listen.o: listen.h
stream_listen.o: msg.h
stream_listen.o: stream_listen.c
stream_listen.o: sys_defs.h
stream_recv_fd.o: iostuff.h
stream_recv_fd.o: msg.h
stream_recv_fd.o: stream_recv_fd.c
stream_recv_fd.o: sys_defs.h
stream_send_fd.o: iostuff.h
stream_send_fd.o: msg.h
stream_send_fd.o: stream_send_fd.c
stream_send_fd.o: sys_defs.h
stream_test.o: check_arg.h
stream_test.o: connect.h
stream_test.o: htable.h
stream_test.o: iostuff.h
stream_test.o: listen.h
stream_test.o: msg.h
stream_test.o: msg_vstream.h
stream_test.o: stream_test.c
stream_test.o: sys_defs.h
stream_test.o: vbuf.h
stream_test.o: vstream.h
stream_trigger.o: connect.h
stream_trigger.o: events.h
stream_trigger.o: iostuff.h
stream_trigger.o: msg.h
stream_trigger.o: mymalloc.h
stream_trigger.o: stream_trigger.c
stream_trigger.o: sys_defs.h
stream_trigger.o: trigger.h
sys_compat.o: sys_compat.c
sys_compat.o: sys_defs.h
timecmp.o: timecmp.c
timecmp.o: timecmp.h
timed_connect.o: iostuff.h
timed_connect.o: msg.h
timed_connect.o: sane_connect.h
timed_connect.o: sys_defs.h
timed_connect.o: timed_connect.c
timed_connect.o: timed_connect.h
timed_read.o: iostuff.h
timed_read.o: msg.h
timed_read.o: sys_defs.h
timed_read.o: timed_read.c
timed_wait.o: msg.h
timed_wait.o: posix_signals.h
timed_wait.o: sys_defs.h
timed_wait.o: timed_wait.c
timed_wait.o: timed_wait.h
timed_write.o: iostuff.h
timed_write.o: msg.h
timed_write.o: sys_defs.h
timed_write.o: timed_write.c
translit.o: check_arg.h
translit.o: stringops.h
translit.o: sys_defs.h
translit.o: translit.c
translit.o: vbuf.h
translit.o: vstring.h
trimblanks.o: check_arg.h
trimblanks.o: stringops.h
trimblanks.o: sys_defs.h
trimblanks.o: trimblanks.c
trimblanks.o: vbuf.h
trimblanks.o: vstring.h
unescape.o: check_arg.h
unescape.o: stringops.h
unescape.o: sys_defs.h
unescape.o: unescape.c
unescape.o: vbuf.h
unescape.o: vstring.h
unix_connect.o: connect.h
unix_connect.o: iostuff.h
unix_connect.o: msg.h
unix_connect.o: sane_connect.h
unix_connect.o: sys_defs.h
unix_connect.o: timed_connect.h
unix_connect.o: unix_connect.c
unix_dgram_connect.o: connect.h
unix_dgram_connect.o: iostuff.h
unix_dgram_connect.o: msg.h
unix_dgram_connect.o: sys_defs.h
unix_dgram_connect.o: unix_dgram_connect.c
unix_dgram_listen.o: htable.h
unix_dgram_listen.o: iostuff.h
unix_dgram_listen.o: listen.h
unix_dgram_listen.o: msg.h
unix_dgram_listen.o: sys_defs.h
unix_dgram_listen.o: unix_dgram_listen.c
unix_listen.o: htable.h
unix_listen.o: iostuff.h
unix_listen.o: listen.h
unix_listen.o: msg.h
unix_listen.o: sane_accept.h
unix_listen.o: sys_defs.h
unix_listen.o: unix_listen.c
unix_pass_fd_fix.o: check_arg.h
unix_pass_fd_fix.o: iostuff.h
unix_pass_fd_fix.o: name_mask.h
unix_pass_fd_fix.o: sys_defs.h
unix_pass_fd_fix.o: unix_pass_fd_fix.c
unix_pass_fd_fix.o: vbuf.h
unix_pass_fd_fix.o: vstring.h
unix_recv_fd.o: iostuff.h
unix_recv_fd.o: msg.h
unix_recv_fd.o: sys_defs.h
unix_recv_fd.o: unix_recv_fd.c
unix_send_fd.o: iostuff.h
unix_send_fd.o: msg.h
unix_send_fd.o: sys_defs.h
unix_send_fd.o: unix_send_fd.c
unix_trigger.o: connect.h
unix_trigger.o: events.h
unix_trigger.o: iostuff.h
unix_trigger.o: msg.h
unix_trigger.o: mymalloc.h
unix_trigger.o: sys_defs.h
unix_trigger.o: trigger.h
unix_trigger.o: unix_trigger.c
unsafe.o: safe.h
unsafe.o: sys_defs.h
unsafe.o: unsafe.c
uppercase.o: check_arg.h
uppercase.o: stringops.h
uppercase.o: sys_defs.h
uppercase.o: uppercase.c
uppercase.o: vbuf.h
uppercase.o: vstring.h
username.o: sys_defs.h
username.o: username.c
username.o: username.h
valid_hostname.o: check_arg.h
valid_hostname.o: msg.h
valid_hostname.o: mymalloc.h
valid_hostname.o: stringops.h
valid_hostname.o: sys_defs.h
valid_hostname.o: valid_hostname.c
valid_hostname.o: valid_hostname.h
valid_hostname.o: vbuf.h
valid_hostname.o: vstring.h
valid_uri_scheme.o: check_arg.h
valid_uri_scheme.o: msg.h
valid_uri_scheme.o: msg_vstream.h
valid_uri_scheme.o: stringops.h
valid_uri_scheme.o: sys_defs.h
valid_uri_scheme.o: valid_uri_scheme.c
valid_uri_scheme.o: valid_uri_scheme.h
valid_uri_scheme.o: vbuf.h
valid_uri_scheme.o: vstream.h
valid_uri_scheme.o: vstring.h
valid_utf8_hostname.o: check_arg.h
valid_utf8_hostname.o: midna_domain.h
valid_utf8_hostname.o: msg.h
valid_utf8_hostname.o: mymalloc.h
valid_utf8_hostname.o: stringops.h
valid_utf8_hostname.o: sys_defs.h
valid_utf8_hostname.o: valid_hostname.h
valid_utf8_hostname.o: valid_utf8_hostname.c
valid_utf8_hostname.o: valid_utf8_hostname.h
valid_utf8_hostname.o: vbuf.h
valid_utf8_hostname.o: vstring.h
valid_utf8_string.o: check_arg.h
valid_utf8_string.o: parse_utf8_char.h
valid_utf8_string.o: stringops.h
valid_utf8_string.o: sys_defs.h
valid_utf8_string.o: valid_utf8_string.c
valid_utf8_string.o: vbuf.h
valid_utf8_string.o: vstring.h
vbuf.o: sys_defs.h
vbuf.o: vbuf.c
vbuf.o: vbuf.h
vbuf_print.o: check_arg.h
vbuf_print.o: msg.h
vbuf_print.o: mymalloc.h
vbuf_print.o: stringops.h
vbuf_print.o: sys_defs.h
vbuf_print.o: vbuf.h
vbuf_print.o: vbuf_print.c
vbuf_print.o: vbuf_print.h
vbuf_print.o: vstring.h
vstream.o: check_arg.h
vstream.o: iostuff.h
vstream.o: msg.h
vstream.o: mymalloc.h
vstream.o: sys_defs.h
vstream.o: vbuf.h
vstream.o: vbuf_print.h
vstream.o: vstream.c
vstream.o: vstream.h
vstream.o: vstring.h
vstream_popen.o: argv.h
vstream_popen.o: check_arg.h
vstream_popen.o: clean_env.h
vstream_popen.o: exec_command.h
vstream_popen.o: iostuff.h
vstream_popen.o: msg.h
vstream_popen.o: set_ugid.h
vstream_popen.o: sys_defs.h
vstream_popen.o: vbuf.h
vstream_popen.o: vstream.h
vstream_popen.o: vstream_popen.c
vstream_tweak.o: check_arg.h
vstream_tweak.o: msg.h
vstream_tweak.o: sys_defs.h
vstream_tweak.o: vbuf.h
vstream_tweak.o: vstream.h
vstream_tweak.o: vstream_tweak.c
vstring.o: check_arg.h
vstring.o: msg.h
vstring.o: mymalloc.h
vstring.o: sys_defs.h
vstring.o: vbuf.h
vstring.o: vbuf_print.h
vstring.o: vstring.c
vstring.o: vstring.h
vstring_vstream.o: check_arg.h
vstring_vstream.o: msg.h
vstring_vstream.o: sys_defs.h
vstring_vstream.o: vbuf.h
vstring_vstream.o: vstream.h
vstring_vstream.o: vstring.h
vstring_vstream.o: vstring_vstream.c
vstring_vstream.o: vstring_vstream.h
warn_stat.o: msg.h
warn_stat.o: sys_defs.h
warn_stat.o: warn_stat.c
warn_stat.o: warn_stat.h
watchdog.o: events.h
watchdog.o: iostuff.h
watchdog.o: killme_after.h
watchdog.o: msg.h
watchdog.o: mymalloc.h
watchdog.o: posix_signals.h
watchdog.o: sys_defs.h
watchdog.o: watchdog.c
watchdog.o: watchdog.h
wrap_stat.o: sys_defs.h
wrap_stat.o: wrap_stat.c
wrap_stat.o: wrap_stat.h
write_buf.o: iostuff.h
write_buf.o: msg.h
write_buf.o: sys_defs.h
write_buf.o: write_buf.c

Messung V0.5 in Prozent
C=100 H=66 G=84

¤ Dauer der Verarbeitung: 0.30 Sekunden  (vorverarbeitet am  2026-08-09) ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Open Source Software

     Quellcodebibliothek
     Eigene Quellcodes
     Fremde Quellcodes
     Suchen

Jenseits des Üblichen ....
    

Besucherstatistik

Besucherstatistik

Statistik
#Sources=277311
#Domains=752002