#
# $Id: Makefile.in,v 1.381 2004/04/23 17:18:34 grubba Exp $
#

# This line is needed on some machines.
@SET_MAKE@

# Don't change this line.  Define EXTRALIBS before this line if you
# wish to add any libraries.
LIBS=@LIBS@ $(EXTRALIBS)

# This is normall the install program in the source directory
INSTALL=@INSTALL@

SRCDIR=@srcdir@
VPATH=@srcdir@

# These are used while compiling
LIBDIR_SRC = @LIBDIR@
TMP_BINDIR = @BINDIR@
TMP_BUILDDIR = @BUILDDIR@
TMP_LIBDIR = $(TMP_BUILDDIR)/lib

# This is used during autodoc extraction.
DOCDIR = @DOCDIR@

# These are used during binary exports and installation.
MANDIR_SRC = @MANDIR@
DOCDIR_SRC = @DOCDIR@
BASEDIR = @BASEDIR@

# These are used by the files generated by fixdepends.sh
PIKE_SRC_DIR=$(SRCDIR)
BUILD_BASE=

#
# RPM and package builders, listen up, because this is your only
# documentation! This variable is prepended to the install path.
# Please note that Pike will not work until moved into the proper
# place.  -Hubbe
# 
buildroot=

prefix = @prefix@
exec_prefix = $(prefix)/bin
lib_prefix = $(prefix)/lib/pike
data_prefix = @datadir@
share_prefix = $(data_prefix)/pike
man_prefix = $(prefix)/man

# Arguments for test_pike.pike used by the verify targets.
# TESTARGS = -F -a

# Arguments for install.pike used by the install targets.
INSTALLARGS = --new-style

#
# use bison please, yacc isn't good enough.
#
YACC=@YACC@
YFLAGS=-d -v

#
# This may be -pg
#
PROFIL=@PROFIL@

#
# OS dependant flags
#
OSFLAGS=

#
#Enable warnings from the compiler, if wanted.
#
WARN=@WARN@

#add extra defines here
DEFINES=@CPPFLAGS@

# -O should work with all compilers
OPTIMIZE=@OPTIMIZE@

# interpret.o can't have -fomit-frame-pointer
INTERPRET_DEOPTIMIZE=@INTERPRET_DEOPTIMIZE@

# Set to a flag for parallelizing make, e.g. -j2. It's given to make
# at the level where it's most effective.
MAKE_PARALLEL=

# Preprocessor flags.
PREFLAGS=-DPIKE_SRC_ROOT="$(BASEDIR)" -I. -I$(SRCDIR) $(DEFINES)
OTHERFLAGS=@CFLAGS@ $(OSFLAGS) $(OPTIMIZE) $(WARN) $(PROFIL)
NOOPTFLAGS=@CFLAGS@ @CPPFLAGS@ $(OSFLAGS) $(WARN) $(PROFIL)
CFLAGS=$(PREFLAGS) $(OTHERFLAGS)

SMARTLINK=@SMARTLINK@
REALCC=@REALCC@
CC=@CC@
CPP=@CPP@

FALLBACK_CC=@FALLBACK_CC@

AR=@AR@

LD=@LD@
LDFLAGS=@LDFLAGS@ @LINKFORSHARED@ $(EXTRALDFLAGS)

DEFAULT_RUNPIKE=$(TMP_BUILDDIR)/pike -DNOT_INSTALLED -DPRECOMPILED_SEARCH_MORE -m$(TMP_BUILDDIR)/master.pike $(PIKEOPTS)
USE_PIKE=pike $(PIKEOPTS)
RUNPIKE=$(@RUNPIKE@)
PIKE_MODULE_RELOC=@PIKE_MODULE_RELOC@

# Set to an appropriate invocation of valgrind (or similar)
VALGRIND=@VALGRIND@
VALGRINDARGS=@VALGRINDARGS@

MAKE_FLAGS=

# Add alloca.o if you don't have alloca() on your machine.
#
OBJ= \
 language.o \
 security.o \
 bignum.o \
 pike_cpulib.o \
 interpret.o \
 constants.o \
 cpp.o \
 fdlib.o \
 cyclic.o \
 array.o \
 backend.o \
 callback.o \
 encode.o \
 docode.o \
 dynamic_buffer.o \
 dynamic_load.o \
 error.o \
 fd_control.o \
 fsort.o \
 gc.o \
 hashtable.o \
 lex.o \
 multiset.o \
 signal_handler.o \
 pike_search.o \
 pike_types.o \
 main.o \
 mapping.o \
 pike_memory.o \
 module_support.o \
 pikecode.o \
 object.o \
 opcodes.o \
 operators.o \
 port.o \
 program.o \
 rbtree.o \
 rusage.o \
 sscanf.o \
 stralloc.o \
 stuff.o \
 threads.o \
 version.o \
 queue.o \
 builtin.o \
 iterators.o \
 svalue.o \
 las.o \
 builtin_functions.o \
 peep.o \
 module.o @EXTRA_OBJS@

MODULE_REQUIREMENTS= \
  machine.h \
  global.h \
  precompile.sh-stamp \
  modules/static_module_makefile \
  modules/dynamic_module_makefile \
  $(SRCDIR)/language.h \
  $(SRCDIR)/interpret_protos.h \
  lib @EXTRA_MODULE_REQUIREMENTS@

SRC_TARGETS= \
 $(SRCDIR)/language.c \
 $(SRCDIR)/language.h \
 $(SRCDIR)/interpret_protos.h \
 $(SRCDIR)/interpret_functions_fixed.h \
 $(SRCDIR)/peep_engine.c \
 $(SRCDIR)/case_info.h \
 $(SRCDIR)/treeopt.h @PMOD_TARGETS@


#
# User callable targets
#

# Update the dumped modules, but only if dump_modules has been used earlier.
#
# Since post_modules might be static, we must remake pike after them
# to make sure they are linked in.
all: module_objects tools
	if [ -f dumpversion ]; then $(MAKE) $(MAKE_FLAGS) dump_modules; else :; fi
	$(MAKE) $(MAKE_FLAGS) $(MAKE_PARALLEL) post_module_objects
	$(MAKE) $(MAKE_FLAGS) $(MAKE_PARALLEL) pike
	@if [ "`find . -name '*.fail' -print`" = "" ]; then :; else \
	  echo; \
	  echo "Pike compiled and linked ok, but the following file(s) "; \
	  echo "failed to compile with full optimization.";\
	  echo "This may affect performance negatively."; \
	  find . -name '*.fail' -print | sed -e 's/\.fail$$//' -e 's/^/	/'; \
	  echo; \
	fi

documentation: onepage.xml traditional.xml modref.xml
	cd $(DOCDIR) && $(MAKE) $(MAKE_FLAGS) PIKE="$(RUNPIKE)" \
	  BUILDDIR="$(TMP_BUILDDIR)" $(DOCTARGET)

# Backward compat.
post_modules: post_module_objects

post_module_objects: pike
	@( cd post_modules ; rm remake >/dev/null 2>&1 || : ; \
	   $(MAKE) $(MAKE_PARALLEL) $(MAKE_FLAGS) || \
	     ( test -f remake && $(MAKE) $(MAKE_PARALLEL) $(MAKE_FLAGS) ) ) || exit $$?

post_modules/modlist_headers.h:
	@test -f post_modules/modlist_headers.h || touch post_modules/modlist_headers.h

post_modules/modlist.h:
	@test -f post_modules/modlist.h || touch post_modules/modlist.h

post_modules/linker_options:
	@test -f post_modules/linker_options || touch post_modules/linker_options

compiler-warnings : clean
	@echo Summarizing compiler warnings.
	@echo
	@if $(MAKE) $(MAKE_FLAGS) all 2>compiler-warnings ; then \
	  echo; \
	  echo 'Compilation warning summary:'; \
	  echo '----------------------------'; \
	else \
	  echo; \
	  echo 'Compilation warning and error summary:'; \
	  echo '--------------------------------------'; \
	fi
	@echo
	@cat compiler-warnings
	@echo
	@echo 'End of summary'
	@echo '--------------'

pike: $(OBJ) master-stamp pike.syms modules/linker_options post_modules/linker_options
	-@if [ -f pike.old ] ; then rm -f pike.old || : ; else : ; fi
	-@if [ -f pike.old.exe ] ; then rm -f pike.old.exe || : ; else : ; fi
	-@if [ -f pike ] ; then mv pike pike.old || : ; else : ; fi
	$(LD) $(LDFLAGS) $(OBJ) `cat modules/linker_options post_modules/linker_options` $(LIBS) -o pike
# The dumped modules are removed whenever Pike is relinked since some
# of the bytecode methods (e.g. ia32) stores absolute addresses to
# global structs. That should probably be fixed in them so that dumped
# modules aren't link order dependent.
	if [ -f dumpversion ]; then $(MAKE) $(MAKE_FLAGS) delete_dumped_modules; else :; fi

# gcov
gcov: 
	@for f in `cd "$(SRCDIR)" && find . -type f -name '*.c' -print`; do \
	  if test -f `echo $$f | sed -e 's/\.$$/.bb/'`; then \
	    for gf in `gcov $$f | sed -e 's/Creating \(.*\)\.gcov.*/\1.gcov/p' -ed`; do \
	      echo "Generating $$f-$$gf."; \
	      test -f "$$f-$$gf" && rm -f "$$f-$$gf"; \
	      mv "$$gf" "$$f-$$gf"; \
	    done; \
	  else \
	    :; \
	  fi; \
	done
	@echo
	@echo "Summary:"
	@for f in `find . -name '*.gcov' -print`; do \
	  grep '######' $$f | \
	  grep -v fatal | \
	  grep -v -i inline | \
	  grep -v PIKE_MODULE_EXIT | \
	  egrep -v '######[ 	]*{$$' | \
	  egrep -v '######[ 	]*}$$' | \
	  wc -l | sed -e "s|^|$$f:|" -e 's/:[   ]*/:/' | \
	  grep -v ':0'; \
	done | sort -n -t: -k2

# purify
pure: $(OBJ) master-stamp module_objects
	-@mv pike pike.old 2>/dev/null || true
	$(SMARTLINK) purify -max-threads=128 -thread_stack_change=8192 -free-queue-length=500 -inuse-at-exit=yes -chain-length=12 $(REALCC) $(LDFLAGS) $(OBJ) `cat modules/linker_options  post_modules/linker_options` $(LIBS) -o pike

# purecov
cover: $(OBJ) master-stamp module_objects
	-@mv pike pike.old 2>/dev/null || true
	$(SMARTLINK) purecov purify -max-threads=128 -thread_stack_change=8192 -free-queue-length=500 -inuse-at-exit=yes -chain-length=12 $(REALCC) $(LDFLAGS) $(OBJ) `cat modules/linker_options  post_modules/linker_options` $(LIBS) -o pike

# quantify
quant: $(OBJ) master-stamp module_objects
	-@mv pike pike.old 2>/dev/null || true
	$(SMARTLINK) quantify $(REALCC) $(LDFLAGS) $(OBJ) `cat modules/linker_options  post_modules/linker_options` $(LIBS) -o pike

atom: pike
	atom pike -tool atom -env threads -g -v `find lib/modules -type f -name '*.so' -print | sed -e 's/^/-incobj /g'`
	mv pike pike.pre-atom
	mv pike.third.threads pike
	@echo Make sure you have '.' in your LD_LIBRARY_PATH.

pixie: pike
	atom pike -tool pixie -env threads -g -v `find lib/modules -type f -name '*.so' -print | sed -e 's/^/-incobj /g'`
	mv pike pike.pre-pixie
	mv pike.pixie.threads pixie
	@echo Make sure you have '.' in your LD_LIBRARY_PATH.

tools: hilfe rsif

hilfe: $(TMP_BINDIR)/hilfe Makefile
	@echo "Creating hilfe..."; \
	( sed -e 's!/usr/bin/env pike!$(exec_prefix)/pike!' \
	  <$(TMP_BINDIR)/hilfe >./hilfe && chmod 755 ./hilfe) || exit 1 ;

rsif: $(TMP_BINDIR)/rsif Makefile
	@echo "Creating rsif..."; \
	( sed -e 's!pike!$(exec_prefix)/pike!' <$(TMP_BINDIR)/rsif \
	  >./rsif && chmod 755 ./rsif) || exit 1 ;

dump_modules: pike master-stamp
	-rm dumpmodule.log
	args="$(DUMPARGS)"; \
	args=$${args:-"--log-file --update-only=dumpversion --report-failed"}; \
	$(RUNPIKE) -x dump $$args \
	--recursive --target-dir=lib "$(LIBDIR_SRC)/modules"

force_dump_modules:
	-rm dumpversion 2>/dev/null
	$(MAKE) $(MAKE_FLAGS) dump_modules

delete_dumped_modules:
	-find lib -type f -name \*.o | xargs rm -f

undump_modules: delete_dumped_modules
	-rm dumpversion 2>/dev/null

.SUFFIXES:
.SUFFIXES: .c .h .o .cmod .pp .pph .protos .h_src

.c.pp:
	$(CPP) $(PREFLAGS) -DPMOD_EXPORT=PMOD_EXPORT \
	  -DPMOD_PROTO=PMOD_PROTO "$<" >"$@"

.c.protos: precompile.sh-stamp
	./precompile.sh --cache fake_dynamic_load.pike >"$@" --cpp --protos \
	  $(CPP) $(PREFLAGS) -DPMOD_EXPORT=PMOD_EXPORT \
	    -DPMOD_PROTO=PMOD_PROTO -DPIKE_PRECOMPILER=1 "$<" || \
	  { rm "$@"; exit 1; }

.h.pph:
	$(CPP) $(PREFLAGS) -DPMOD_EXPORT=PMOD_EXPORT \
	  -DPMOD_PROTO=PMOD_PROTO "$<" >"$@"


# Several optimizers have problems with interpret.c
# First try compiling with optimization and if that doesn't work, without.
# GCC dumps core on some files @ OSF1
# This kluge should work around that...
# Extra kludge added: interpret.o gets special flags (deoptimization)
.c.o:
	@echo "Compiling $<" ;\
	rm -f $@.fail >/dev/null 2>&1; \
	if test "x$@" = "xinterpret.o"; then EXTRAFLAGS="$(INTERPRET_DEOPTIMIZE)"; else EXTRAFLAGS=; fi; \
	if $(CC) $(CFLAGS) $$EXTRAFLAGS -c $< -o $@ ; then : ; else \
	  status=$$?; \
	  if test x"@noopt_retry@" = xyes ; then \
	    echo "WARNING: Compiler failure! Trying without optimization!" >&2;\
	    echo "$(CC) $(PREFLAGS) $(CFLAGS) $$EXTRAFLAGS -c $< -o $@" >$@.fail ;\
	    if NO_ULIMIT=yes $(CC) $(PREFLAGS) $(NOOPTFLAGS) $$EXTRAFLAGS -c $< -o $@ ; then : ; else \
	      status=$$?; \
	      echo "Compilation command was:" >&2;\
	      echo "$(CC) $(PREFLAGS) $(NOOPTFLAGS) $$EXTRAFLAGS -c $< -o $@" >&2 ;\
	      exit $$status; \
	    fi; \
	  else \
	    echo "Compilation command was:" >&2;\
	    echo "$(CC) $(PREFLAGS) $(CFLAGS) $$EXTRAFLAGS -c $< -o $@" >&2 ;\
	    exit $$status; \
	  fi; \
	fi

#
# Please note that this must be accompanied by a dependency rule as
# The .c file will not be created in the SOURCE directory otherwise.
# -Hubbe
#
.cmod.c: precompile.sh-stamp $(TMP_BINDIR)/precompile.pike
	./precompile.sh --cache precompile.pike >"$@" "$<" || { rm "$@"; exit 1; }

# This rule is used for some header files that are generated from the
# source, to avoid excessive rebuilding when the source change in ways
# that doesn't affect the header.
#
# It can cause a .h target to be out-of-date repeatedly, but since it
# runs fast that's not an issue. This technique only works well in
# make's that stat the target again after the rule has run and
# recalculate the dependencies from that. Most make's seems to behave
# like that.
.h_src.h:
	@if test -f "$@"; then \
	  test -f "$@.nolines" || \
	    sed -e '/^[ \t]*$$/d;/^[ \t]*#[ \t]*line.*$$/d' < "$@" > "$@.nolines" && \
	  sed -e '/^[ \t]*$$/d;/^[ \t]*#[ \t]*line.*$$/d' < "$<" > "$<.nolines" && \
	  cmp -s "$<.nolines" "$@.nolines"; \
	else \
	  false; \
	fi || ( \
	  rm -f "$@.nolines" 2>/dev/null; \
	  echo "cp $< $@"; \
	  cp "$<" "$@"; \
	)

force :
	@:

# install
install: pike tools
	@if [ -f autodoc.xml ]; then : ; else \
	  echo ; \
	  echo 'No documentation source built!'; \
	  echo 'Type "make doc" to make a documentation source file'; \
	  echo 'or "make install_nodoc" to install without a documentation'; \
	  echo 'source.' ; \
	  echo ; \
	  exit 1; \
	fi
	@$(RUNPIKE) $(TMP_BINDIR)/install.pike \
	exec_prefix="$(exec_prefix)" lib_prefix="$(lib_prefix)" \
	TMP_LIBDIR="$(TMP_LIBDIR)" LIBDIR_SRC="$(LIBDIR_SRC)" \
	SRCDIR="$(SRCDIR)" prefix="$(prefix)" DOCDIR_SRC="$(DOCDIR_SRC)" \
	MANDIR_SRC="$(MANDIR_SRC)" \
	man_prefix="$(man_prefix)" pike_name=$(pike_name) \
	fakeroot="$(buildroot)" PIKE_MODULE_RELOC="$(PIKE_MODULE_RELOC)" \
	$(INSTALLARGS)

install_nodoc: pike tools
	@$(RUNPIKE) $(TMP_BINDIR)/install.pike \
	exec_prefix="$(exec_prefix)" lib_prefix="$(lib_prefix)" \
	TMP_LIBDIR="$(TMP_LIBDIR)" LIBDIR_SRC="$(LIBDIR_SRC)" \
	SRCDIR="$(SRCDIR)" prefix="$(prefix)" DOCDIR_SRC="$(DOCDIR_SRC)" \
	MANDIR_SRC="$(MANDIR_SRC)" \
	man_prefix="$(man_prefix)" pike_name=$(pike_name) \
	fakeroot="$(buildroot)" PIKE_MODULE_RELOC="$(PIKE_MODULE_RELOC)" \
	--no-autodoc $(INSTALLARGS)

install_interactive: pike tools
	@if [ -f autodoc.xml ]; then : ; else \
	  echo ; \
	  echo 'No documentation source built!'; \
	  echo 'Type "make doc" to make a documentation source file'; \
	  echo 'or "make install_interactive_nodoc" to install without a'; \
	  echo 'documentation source.' ; \
	  echo ; \
	  exit 1; \
	fi
	@$(RUNPIKE) $(TMP_BINDIR)/install.pike --interactive \
	exec_prefix="$(exec_prefix)"  prefix=$(prefix) \
	TMP_LIBDIR="$(TMP_LIBDIR)" LIBDIR_SRC="$(LIBDIR_SRC)" \
	SRCDIR="$(SRCDIR)" DOCDIR_SRC="$(DOCDIR_SRC)" \
	MANDIR_SRC="$(MANDIR_SRC)" \
	fakeroot="$(buildroot)" PIKE_MODULE_RELOC="$(PIKE_MODULE_RELOC)"

install_interactive_nodoc: pike tools
	@$(RUNPIKE) $(TMP_BINDIR)/install.pike --interactive \
	exec_prefix="$(exec_prefix)"  prefix=$(prefix) \
	TMP_LIBDIR="$(TMP_LIBDIR)" LIBDIR_SRC="$(LIBDIR_SRC)" \
	SRCDIR="$(SRCDIR)" DOCDIR_SRC="$(DOCDIR_SRC)" \
	MANDIR_SRC="$(MANDIR_SRC)" \
	fakeroot="$(buildroot)" PIKE_MODULE_RELOC="$(PIKE_MODULE_RELOC)" \
	--no-autodoc

# tidy up a bit
tidy:
	-rm -f *.fail *.o *.obj *.pp *.protos core y.output y.tab.c y.tab.h
	-rm -f $(TMP_BINDIR)/core *.o *.i *.i~ dynloadtest*
	-rm testsuite testsuite.tmp testsuite_test.pike testsuite_test_dir.pmod
	-find lib -type f -name \*.o | xargs rm -f

# make clean
clean_here: tidy doc_clean
	-( cd tlib; find . -name testsuite | xargs rm )
	-( cd extra_tests; find . -name testsuite | xargs rm )
	-rm -f confdefs.h conftest.*
	-rm -rf test-install test-pike
	-rm -f TAGS tags yacc.acts yacc.debug yacc.tmp *.debug.log a.out pike.tmp
	-rm -f hilfe rsif master.pike compiler-warnings dumpmodule.log
	-rm -f interpreter_debug.h lexer?.h
	-rm -f import-stamp modules-stamp master-stamp
	-rm -rf lib/modules/*
#	-rm -f lib/master.pike

clean: clean_here
	-( cd modules; $(MAKE) $(MAKE_FLAGS) clean )
	-( cd post_modules; $(MAKE) $(MAKE_FLAGS) clean )

# make _really_ clean
spotless: clean_here
	-( cd modules; $(MAKE) $(MAKE_FLAGS) spotless )
	-( cd post_modules; $(MAKE) $(MAKE_FLAGS) spotless )
	-(cd $(SRCDIR); find . -type f -name '*.h.in' -print) | \
	  sed -e 's/\.in$$//' | xargs rm -f
	-rm -f Makefile config.* make_variables specs pike.syms
	-rm -f core core.* .pure stamp-h
	-rm -f lexical.c mon.out *.ln
	-rm -f pike pike.old l.outa* num_files_to_install
	-rm -f precompile.sh precompile.sh-stamp smartlink
	-rm -rf tlib extra_tests lib precompile

distclean: spotless

cvsclean: distclean
	( for d in `cd $(SRCDIR) && find . -type d -print`; do \
	    if test -f "$(SRCDIR)/$$d/.cvsignore" ; then \
	      (cd "$$d" && rm -f `cat "$(SRCDIR)/$$d/.cvsignore"`); \
	      (cd "$(SRCDIR)/$$d" && rm -f `cat "$(SRCDIR)/$$d/.cvsignore"`); \
	    else :; fi; \
	  done)

# create tags
tags:
	ctags *.c

TAGS:
	etags -t *.h *.c

# verify / debug
testsuites:
	( cd modules && $(MAKE) $(MAKE_FLAGS) testsuites )
	( cd post_modules && $(MAKE) $(MAKE_FLAGS) testsuites )
	( cd $(TMP_BUILDDIR) && $(TMP_BINDIR)/mklibtests.sh \
	  --srcdir=$(LIBDIR_SRC) \
	  --destdir=tlib --bindir=$(TMP_BINDIR) )
	if test -d "$(BASEDIR)/extra_tests" ; then \
	  (cd "$(TMP_BUILDDIR)" && $(TMP_BINDIR)/mklibtests.sh \
	   --srcdir="$(BASEDIR)/extra_tests" \
	   --destdir=extra_tests --bindir=$(TMP_BINDIR) ) ; fi;

just_verify: testsuites testsuite master-stamp
	if test "x$(TESTARGS)" = x ; then args="-F -a -v" ; \
	else args="$(TESTARGS)" ; fi; \
	$(RUNPIKE) $(TMP_BINDIR)/test_pike.pike $$args

valgrind_verify: testsuites testsuite master-stamp
	if test "x$(TESTARGS)" = x ; then args="-F -a -v" ; \
	else args="$(TESTARGS)" ; fi; \
	$(VALGRIND) $(VALGRINDARGS) $(RUNPIKE) $(TMP_BINDIR)/test_pike.pike $$args

# Testsuite for dynamic loading debugging
test_dlopen: dynloadtest.sh
	sh ./dynloadtest.sh

dynloadtest.sh: $(SRCDIR)/test_dynamic_loading.in
	m4 "$(SRCDIR)/test_dynamic_loading.in" >"$@"

dynloadtest.c: dynamic_load.c

dynloadtest: dynloadtest.o @EXTRA_OBJS@ fdlib.o port.o
	$(LD) $(LDFLAGS) dynloadtest.o @EXTRA_OBJS@ fdlib.o port.o $(LIBS) -o dynloadtest


tinstall: master-stamp
	-rm -rf test-install
	$(RUNPIKE) $(TMP_BINDIR)/install.pike --no-autodoc \
	lib_prefix="$(lib_prefix)" \
	TMP_LIBDIR="$(TMP_LIBDIR)" LIBDIR_SRC="$(LIBDIR_SRC)" \
	SRCDIR="$(SRCDIR)" DOCDIR_SRC="$(DOCDIR_SRC)" \
	MANDIR_SRC="$(MANDIR_SRC)" \
	man_prefix="$(man_prefix)" fakeroot="$(buildroot)" \
	PIKE_MODULE_RELOC="$(PIKE_MODULE_RELOC)" pike_name="test-pike" \
	prefix="./test-install" $(INSTALLARGS)

just-tinstall: master-stamp
	$(RUNPIKE) $(TMP_BINDIR)/install.pike --no-autodoc \
	lib_prefix="$(lib_prefix)" \
	TMP_LIBDIR="$(TMP_LIBDIR)" LIBDIR_SRC="$(LIBDIR_SRC)" \
	SRCDIR="$(SRCDIR)" DOCDIR_SRC="$(DOCDIR_SRC)" \
	MANDIR_SRC="$(MANDIR_SRC)" \
	man_prefix="$(man_prefix)" fakeroot="$(buildroot)" \
	PIKE_MODULE_RELOC="$(PIKE_MODULE_RELOC)" pike_name="test-pike" \
	prefix="./test-install" $(INSTALLARGS)


verify: testsuites testsuite tinstall
	PIKE_MODULE_PATH=""; PIKE_INCLUDE_PATH=""; \
	if test "$(TESTARGS)" = "" ; then args="-F -a -v" ; else \
	  args="$(TESTARGS)" ; fi; \
	if test -f ./test-pike ; then \
	  $(VALGRIND) $(VALGRINDARGS) ./test-pike -DNOT_INSTALLED $(PIKEOPTS) $(TMP_BINDIR)/test_pike.pike $$args ; \
	else \
	  sprsh `pwd`/test-install/pike/*/bin/pike.exe -DNOT_INSTALLED $(PIKEOPTS) $(TMP_BINDIR)/test_pike.pike $$args ; \
	fi

bench: tinstall
	if test -f ./test-pike ; then \
	  ./test-pike -DNOT_INSTALLED $(PIKEOPTS) -x benchmark; \
	else \
	  sprsh `pwd`/test-install/pike/*/bin/pike.exe -DNOT_INSTALLED $(PIKEOPTS) -x benchmark ; \
	fi

verify_installed: testsuites testsuite master-stamp
	if test "$(TESTARGS)" = "" ; then args="-F -a -v" ; else \
	  args="$(TESTARGS)" ; fi; \
	$(exec_prefix)/pike $(PIKEOPTS) $(TMP_BINDIR)/test_pike.pike $$args

check: verify

sure: verify

# verify / debug verbose
verbose_verify: testsuites testsuite master-stamp
	if test "$(TESTARGS)" = "" ; then args="-F -a" ; else args="$(TESTARGS)" ; fi; \
	$(RUNPIKE) $(TMP_BINDIR)/test_pike.pike -v -v $$args

# verify & debug VERBOSE
gdb_verify: testsuites testsuite master-stamp
	@echo >.gdbinit handle SIGFPE nostop noprint pass
	@echo >>.gdbinit handle SIGUSR1 nostop noprint pass
	@echo >>.gdbinit handle SIGUSR2 nostop noprint pass
	@echo >>.gdbinit handle SIGLWP nostop noprint pass
	@if kill -l | grep SIGRTMIN >/dev/null ; then \
	  echo >>.gdbinit handle SIG32 nostop noprint pass ;\
	else :; fi
	@echo >>.gdbinit break debug_fatal
	@echo >>.gdbinit break pike_gdb_breakpoint
	@if test "$(TESTARGS)" = "" ; then args="-F -a -v -v" ; else \
	  args="$(TESTARGS)" ; fi;  \
	echo >>.gdbinit set args -m$(TMP_BUILDDIR)/master.pike $(PIKEOPTS) $(TMP_BINDIR)/test_pike.pike --no-watchdog $$args
	gdb $(TMP_BUILDDIR)/pike
	@rm .gdbinit

gdb_hilfe: master.pike
	@echo >.gdbinit handle SIGFPE nostop noprint pass
	@echo >>.gdbinit handle SIGUSR1 nostop noprint pass
	@echo >>.gdbinit handle SIGUSR2 nostop noprint pass
	@echo >>.gdbinit handle SIGLWP nostop noprint pass
	@if kill -l | grep SIGRTMIN >/dev/null ; then \
	  echo >>.gdbinit handle SIG32 nostop noprint pass ;\
	else :; fi
	@echo >>.gdbinit break debug_fatal
	@echo >>.gdbinit break pike_gdb_breakpoint
	@echo >>.gdbinit set args -m$(TMP_BUILDDIR)/master.pike $$ARGS
	gdb $(TMP_BUILDDIR)/pike
	@rm .gdbinit

# fast test
fast_verify_testsuite: testsuite
	PIKE_MODULE_PATH=""; PIKE_INCLUDE_PATH=""; \
	if test "$(TESTARGS)" = "" ; then args="-F -a" ; else args="$(TESTARGS)" ; fi; \
	if test -f ./test-pike ; then ./test-pike -DNOT_INSTALLED $(PIKEOPTS) $(TMP_BINDIR)/test_pike.pike $$args ; else sprsh `pwd`/test-install/pike/*/bin/pike.exe -DNOT_INSTALLED $(PIKEOPTS) $(TMP_BINDIR)/test_pike.pike $$args ; fi

# run hilfe, for interactive testing
run_hilfe: master.pike
	$(RUNPIKE) $(ARGS)

valgrind_hilfe: master.pike
	$(VALGRIND) $(VALGRINDARGS) $(RUNPIKE) $(ARGS)

feature_list:
	$(RUNPIKE) $(TMP_BINDIR)/feature_list

run_bench:
	$(RUNPIKE) $(ARGS) -x benchmark

lib: Makefile
	@for d in lib lib/modules lib/include; do \
	  if [ -d $$d/. ]; then : ; else \
	    echo "Creating $$d/."; \
	    (mkdir $$d && chmod u+rwx $$d) || exit 1; \
	  fi ; \
	done
	@echo "Done."
	-@touch ./lib 2>/dev/null || (touch lib/.broken_gnu_touch && rm lib/.broken_gnu_touch)


master.pike: $(LIBDIR_SRC)/master.pike.in Makefile
	t="$$PIKE_PATH_TRANSLATE"; if test "x$$t" = "x"; then t=s,x,x,; else :; fi; \
	if test "x$(PIKE_MODULE_RELOC)" = "x"; then u=s,x,x,; else u='s/^#undef PIKE_MODULE_RELOC/#define PIKE_MODULE_RELOC 1/'; fi; \
	sed -e 's!¤lib_prefix¤!'"`echo "$(TMP_LIBDIR)" | sed -e "$$t"`"'!' <$(LIBDIR_SRC)/master.pike.in \
	  | sed -e 's!¤share_prefix¤!'"`echo "$(LIBDIR_SRC)" | sed -e "$$t"`"'!' \
	  | sed -e 's!¤include_prefix¤!'"`echo "$(TMP_BUILDDIR)" | sed -e "$$t"`"'!' \
	  | sed -e "$$u" >master.pike

# Want master.pike up-to-date, but yet there's no dependency on the
# that file. Works like the .h_src.h target.
master-stamp: master.pike
	@test -f master-stamp || echo foo > master-stamp

#
# Documentation related stuff.
#

onepage.xml: autodoc.xml $(DOCDIR)/structure/onepage.xml
	(cd "$(DOCDIR)" && \
	  $(RUNPIKE) -x assemble_autodoc structure/onepage.xml \
	    $(TMP_BUILDDIR)/autodoc.xml) >onepage.xml

traditional.xml: autodoc.xml $(DOCDIR)/structure/traditional.xml
	( cd "$(DOCDIR)" && \
	  $(RUNPIKE) -x assemble_autodoc structure/traditional.xml \
	    $(TMP_BUILDDIR)/autodoc.xml) >traditional.xml

modref.xml: autodoc.xml $(DOCDIR)/structure/modref.xml
	(cd "$(DOCDIR)" && \
	  $(RUNPIKE) -x assemble_autodoc structure/modref.xml \
	    $(TMP_BUILDDIR)/autodoc.xml) >modref.xml

autodoc.xml: pike doc_build/src doc_build/lib doc_build/images images force
	$(RUNPIKE) -x extract_autodoc -q --srcdir=$(SRCDIR) \
	  --imgsrc=$(DOCDIR)/src_images --builddir=doc_build/src \
	  --imgdir=doc_build/images
	$(RUNPIKE) -x extract_autodoc -q --srcdir=$(LIBDIR_SRC) \
	  --imgsrc=$(DOCDIR)/src_images --builddir=doc_build/lib \
	  --imgdir=doc_build/images
	$(RUNPIKE) -x join_autodoc --quiet --post-process autodoc.xml doc_build

autodoc-stamp:
	@test -f autodoc.xml || $(MAKE) $(MAKEFLAGS) autodoc.xml
	@test -f autodoc-stamp || echo foo > autodoc-stamp

images: doc_build/src/post_modules/GTK/refdoc/images
	@cp $(SRCDIR)/post_modules/GTK/refdoc/images/*.png \
	  doc_build/src/post_modules/GTK/refdoc/images/

# Directories

doc_build:
	@test -d doc_build || mkdir doc_build

doc_build/src: doc_build
	@test -d doc_build/src || mkdir doc_build/src

doc_build/lib: doc_build
	@test -d doc_build/lib || mkdir doc_build/lib

doc_build/images: doc_build
	@test -d doc_build/images || mkdir doc_build/images

doc_build/src/post_modules/GTK/refdoc/images: doc_build/src
	@test -d doc_build/src/post_modules || \
	  mkdir doc_build/src/post_modules
	@test -d doc_build/src/post_modules/GTK || \
	  mkdir doc_build/src/post_modules/GTK
	@test -d doc_build/src/post_modules/GTK/refdoc || \
	  mkdir doc_build/src/post_modules/GTK/refdoc
	@test -d doc_build/src/post_modules/GTK/refdoc/images || \
	  mkdir doc_build/src/post_modules/GTK/refdoc/images

doc_clean:
	-rm -f onepage.xml traditional.xml modref.xml autodoc.xml resolution.log
	-rm -rf doc_build


pike.syms: $(SRCDIR)/interpret.c $(SRCDIR)/interpreter.h $(SRCDIR)/program.c $(SRCDIR)/builtin_functions.c
	( cat $(SRCDIR)/*.h *.h | egrep  '^[  ]*#[     ]*define[      ][       ]*[a-zA-Z_0-9]*[       ][      ]*[0-9][xabcdefABCDEF0-9]*[  ]*' ; \
	echo "#define" `$(CPP) $(PREFLAGS) -DSTEP_BREAK_LINE='STEP_BREAK_LINE __LINE__' $(SRCDIR)/interpreter.h | grep STEP_BREAK_LINE` ) >pike.syms

# We touch the files that depend on language.h_src and
# interpret_protos.h_src to ensure that the .h_src.h rule doesn't have
# anything to do in the dist.
source: depend
	if test -f $(SRCDIR)/language.c; then touch $(SRCDIR)/language.c; else :; fi
	if test -f $(SRCDIR)/language.h; then touch $(SRCDIR)/language.h; else :; fi
	if test -f $(SRCDIR)/interpret_protos.h; then touch $(SRCDIR)/interpret_protos.h; else :; fi

# make export archive (requires compiled Pike)
# Do not compile in source tree if you want to use this!
# Beware that export archive this includes bison/yacc/byacc source
# and thus has to follow the rules stated in that code.

full_export: source
	chmod +x $(SRCDIR)/install-sh
	$(RUNPIKE) $(TMP_BINDIR)/export.pike --srcdir="$(SRCDIR)"  \
	--exportlist=src/export_list --name=Pike-v%maj.%min.%bld --tag

EXPORT_NAME=Pike-v%maj.%min-%Y%M%D
snapshot_export: source
	chmod +x $(SRCDIR)/install-sh
	$(RUNPIKE) $(TMP_BINDIR)/export.pike --srcdir="$(SRCDIR)"  \
	--exportlist=src/export_list --name=$(EXPORT_NAME) $(EXPORTARGS)

export: full_export

bin_export: 
	@rm -f *.burk
	@no_autodoc="--no-autodoc"; \
	if [ -f autodoc.xml ]; then no_autodoc=""; fi; \
	$(RUNPIKE) $(TMP_BINDIR)/install.pike --export $$no_autodoc \
	exec_prefix="$(exec_prefix)" lib_prefix="$(lib_prefix)" \
	TMP_LIBDIR="$(TMP_LIBDIR)" LIBDIR_SRC="$(LIBDIR_SRC)" \
	SRCDIR="$(SRCDIR)" prefix="$(prefix)" DOCDIR_SRC="$(DOCDIR_SRC)" \
	MANDIR_SRC="$(MANDIR_SRC)" \
	BASEDIR="$(BASEDIR)" man_prefix="$(man_prefix)" \
	pike_name=$(pike_name) PIKE_MODULE_RELOC="$(PIKE_MODULE_RELOC)"
	@case " $(CC)" in \
	  *\ rnt*) \
	    $(MAKE) $(MAKE_FLAGS) uncompress_header ;\
	    echo "Compressing..." ;\
	    filename=`echo *.burk | sed 's@\.burk$$@@g'`.exe ;\
	    ( cat uncompress_header.exe ; gzip -9 -c *.burk ) > $$filename ;\
	    echo "Done." ;\
	  ;; \
	esac

#new_peep_engine:
#	$(RUNPIKE) $(TMP_BINDIR)/mkpeep.pike $(SRCDIR)/peep.in >$(SRCDIR)/peep_engine.c
#	$(RUNPIKE) $(TMP_BINDIR)/make_ci.pike <$(SRCDIR)/UnicodeData.txt >$(SRCDIR)/case_info.h

$(SRCDIR)/peep_engine.c: $(SRCDIR)/peep.in $(TMP_BINDIR)/mkpeep.pike
	./precompile.sh $(TMP_BINDIR)/mkpeep.pike $(SRCDIR)/peep.in >$(SRCDIR)/peep_engine.c || ( rm $(SRCDIR)/peep_engine.c ; exit 1 )

peep.o: $(SRCDIR)/peep_engine.c

$(SRCDIR)/case_info.h: $(SRCDIR)/UnicodeData.txt $(TMP_BINDIR)/make_ci.pike
	./precompile.sh $(TMP_BINDIR)/make_ci.pike $(SRCDIR)/case_info.h \
	  <$(SRCDIR)/UnicodeData.txt

builtin_functions.o: $(SRCDIR)/case_info.h $(SRCDIR)/combine_path.h

$(SRCDIR)/treeopt.h: $(SRCDIR)/treeopt.in $(TMP_BINDIR)/mktreeopt.pike
	./precompile.sh $(TMP_BINDIR)/mktreeopt.pike $(SRCDIR)/treeopt.in || ( rm $(SRCDIR)/treeopt.h ; exit 1 )

las.o: $(SRCDIR)/treeopt.h

# This dependency is here to make sure that lexer[012].h are generated.
# The reason for the split is that some compilers (read cl) generate
# better code then. Strange, but true.
lex.o: lexer0.h lexer1.h lexer2.h

lex.protos: lexer0.h lexer1.h lexer2.h

lexer0.h: lexer.h
	cp "$(SRCDIR)/lexer.h" "$@"

lexer1.h: lexer.h
	cp "$(SRCDIR)/lexer.h" "$@"

lexer2.h: lexer.h
	cp "$(SRCDIR)/lexer.h" "$@"


# unbug needs interpreter_nd.h to be able to
# set separate breakpoints in eval_instruction_with/without_debug
interpreter_debug.h: interpreter.h
	cp "$(SRCDIR)/interpreter.h" "$@"

interpret.o: interpreter_debug.h $(SRCDIR)/interpret_functions_fixed.h

# make dependencies
depend: $(SRC_TARGETS)
	gcc -MM -MG $(PREFLAGS) $(SRCDIR)/*.c | $(TMP_BINDIR)/fixdepends.sh "$(SRCDIR)" "$(SRCDIR)" /dev/null
	-@(while :; do \
	  echo foo > cfl.$@; test "`echo cfl.*`" = cfl.$@ && break; \
	  rm cfl.$@; echo "Waiting to run config.status serially:" cfl.*; sleep 1; \
	  arb=37; while test $$arb != 0; do arb=`expr $$arb - 1`; done; \
	done;)
	CONFIG_FILES=Makefile CONFIG_HEADERS="" ./config.status || \
	  (EXITCODE=$$?; rm cfl.$@; exit $$EXITCODE)
	-@rm cfl.$@
	@( cd modules && { \
	  rm -f remake; \
	  $(MAKE) $(MAKE_FLAGS) depend || \
	    { test -f remake && $(MAKE) $(MAKE_FLAGS) depend; }; \
	})
	@if [ "x$(RUNPIKE)" != "x$(DEFAULT_RUNPIKE)" -o -x $(TMP_BUILDDIR)/pike ]; then \
	  $(MAKE) $(MAKE_FLAGS) post_modules_depend; \
	else \
	  echo "Skipping make depend in post_modules since a fresh pike is"; \
	  echo "needed to make the autogenerated sources there."; \
	  :; \
	fi

post_modules_depend:
	@if [ "x$(RUNPIKE)" != "x$(DEFAULT_RUNPIKE)" -o -x $(TMP_BUILDDIR)/pike ]; then :; \
	else $(MAKE) $(MAKE_FLAGS) $(MAKE_PARALLEL) pike; fi
	@( cd post_modules && { \
	  rm -f remake; \
	  $(MAKE) $(MAKE_FLAGS) depend || \
	    { test -f remake && $(MAKE) $(MAKE_FLAGS) depend; }; \
	})

#
# Pike internal targets
#

# touch modules-stamp here to avoid doing this work again if that
# target is checked later.
module_objects: $(MODULE_REQUIREMENTS)
	@( cd modules ; rm remake >/dev/null 2>&1 || : ; \
	   $(MAKE) $(MAKE_PARALLEL) $(MAKE_FLAGS) || \
	     ( test -f remake && $(MAKE) $(MAKE_PARALLEL) $(MAKE_FLAGS) ) ) || exit $$?
	@touch modules-stamp

modules-stamp: $(MODULE_REQUIREMENTS)
	@( cd modules ; rm remake >/dev/null 2>&1 || : ; \
	   $(MAKE) $(MAKE_PARALLEL) $(MAKE_FLAGS) || \
	     ( test -f remake && $(MAKE) $(MAKE_PARALLEL) $(MAKE_FLAGS) ) ) || exit $$?
	@touch modules-stamp

modules/modlist.h: modules-stamp

modules/modlist_headers.h: modules-stamp

modules/linker_options: modules-stamp

module.o:  modules/modlist_headers.h modules/modlist.h

$(SRCDIR)/interpret_protos.h_src: $(SRCDIR)/interpret_functions.h $(SRCDIR)/strip_opcodes
	$(CPP) $(PREFLAGS) -DGEN_PROTOS $(SRCDIR)/interpret_functions.h | $(SRCDIR)/strip_opcodes >$(SRCDIR)/interpret_protos.h_src || { rm $(SRCDIR)/interpret_protos.h_src; exit 1; }

lex.o: $(SRCDIR)/lex.c $(SRCDIR)/interpret_protos.h

interpret.o: $(SRCDIR)/lex.c $(SRCDIR)/interpret_protos.h

lex_t.o: $(SRCDIR)/lex_t.c $(SRCDIR)/interpret_protos.h

language.o: $(SRCDIR)/language.c $(SRCDIR)/object.h $(SRCDIR)/interpret.h $(SRCDIR)/program.h

$(SRCDIR)/language.c $(SRCDIR)/language.h_src: $(SRCDIR)/language.yacc
	@echo "Expect 1 shift/reduce conflict."
	( cd $(SRCDIR) && \
	 $(YACC) $(YFLAGS) $(SRCDIR)/language.yacc && \
	 sed -e 's/YY_COUNT_TYPE/@YY_COUNT_TYPE@/' \
	     -e 's/YY_FROM_CONST/@YY_FROM_CONST@/' <y.tab.c >language.c && \
	 mv y.tab.h language.h_src && rm y.tab.c)

$(SRCDIR)/interpret_functions_fixed.h: $(SRCDIR)/interpret_functions.h precompile.sh-stamp
	./precompile.sh --cache make_interpret_functions.pike >"$@" "$(SRCDIR)/interpret_functions.h" || { rm "$@"; exit 1; }

# UnixWare make needs help to find the source file...
builtin.o: $(SRCDIR)/builtin.c

iterators.o: $(SRCDIR)/iterators.c

backend.o: $(SRCDIR)/backend.c

# Internal testing target
run_yacc: $(SRCDIR)/language.c

$(SRCDIR)/configure $(SRCDIR)/stamp-h.in: $(SRCDIR)/configure.in $(SRCDIR)/aclocal.m4 $(SRCDIR)/acconfig.h
	cd $(SRCDIR) && ./run_autoconfig --no-recursion .
	echo foo > $(SRCDIR)/stamp-h.in

config.status: $(SRCDIR)/configure
	./config.status --recheck

modules/common_module_makefile: $(SRCDIR)/modules/common_module_makefile.in config.status
	-@(while :; do \
	  echo foo > cfl.common_module_makefile; test "`echo cfl.*`" = cfl.common_module_makefile && break; \
	  rm cfl.common_module_makefile; echo "Waiting to run config.status serially:" cfl.*; sleep 1; \
	  arb=17; while test $$arb != 0; do arb=`expr $$arb - 1`; done; \
	done;)
	CONFIG_FILES=modules/common_module_makefile CONFIG_HEADERS="" ./config.status || \
	  (EXITCODE=$$?; rm cfl.common_module_makefile; exit $$EXITCODE)
	-@rm cfl.common_module_makefile

modules/static_module_makefile: modules/common_module_makefile $(SRCDIR)/modules/static_module_makefile.in config.status
	-@(while :; do \
	  echo foo > cfl.static_module_makefile; test "`echo cfl.*`" = cfl.static_module_makefile && break; \
	  rm cfl.static_module_makefile; echo "Waiting to run config.status serially:" cfl.*; sleep 1; \
	  arb=17; while test $$arb != 0; do arb=`expr $$arb - 1`; done; \
	done;)
	CONFIG_FILES=modules/static_module_makefile CONFIG_HEADERS="" ./config.status || \
	  (EXITCODE=$$?; rm cfl.static_module_makefile; exit $$EXITCODE)
	-@rm cfl.static_module_makefile

modules/dynamic_module_makefile: modules/common_module_makefile $(SRCDIR)/@dmmsrc@ config.status
	-@(while :; do \
	  echo foo > cfl.dynamic_module_makefile; test "`echo cfl.*`" = cfl.dynamic_module_makefile && break; \
	  rm cfl.dynamic_module_makefile; echo "Waiting to run config.status serially:" cfl.*; sleep 1; \
	  arb=19; while test $$arb != 0; do arb=`expr $$arb - 1`; done; \
	done;)
	CONFIG_FILES=modules/dynamic_module_makefile:@dmmsrc@ CONFIG_HEADERS="" ./config.status || \
	  (EXITCODE=$$?; rm cfl.dynamic_module_makefile; exit $$EXITCODE)
	-@rm cfl.dynamic_module_makefile

Makefile: $(SRCDIR)/Makefile.in $(SRCDIR)/dependencies config.status
	-@(while :; do \
	  echo foo > cfl.$@; test "`echo cfl.*`" = cfl.$@ && break; \
	  rm cfl.$@; echo "Waiting to run config.status serially:" cfl.*; sleep 1; \
	  arb=23; while test $$arb != 0; do arb=`expr $$arb - 1`; done; \
	done;)
	CONFIG_FILES=Makefile CONFIG_HEADERS="" ./config.status || \
	  (EXITCODE=$$?; rm cfl.$@; exit $$EXITCODE)
	-@rm cfl.$@
	touch remake
	@echo "Run make again"
	@exit 1

precompile.sh: $(SRCDIR)/precompile.sh.in ./config.status
	-@(while :; do \
	  echo foo > cfl.$@; test "`echo cfl.*`" = cfl.$@ && break; \
	  rm cfl.$@; echo "Waiting to run config.status serially:" cfl.*; sleep 1; \
	  arb=29; while test $$arb != 0; do arb=`expr $$arb - 1`; done; \
	done;)
	CONFIG_FILES=precompile.sh CONFIG_HEADERS="" ./config.status || \
	  (EXITCODE=$$?; rm cfl.$@; exit $$EXITCODE)
	-@rm cfl.$@

# A dependency on precompile.sh-stamp only ensures that precompile.sh
# exists, not that it's older than the target. In source dists,
# precompile.sh is almost always newer than the targets that depend on
# it, e.g. builtin.c that comes with the dist.
#
# The date stamp used to be 0103000070, but that seems to confuse some
# recent OS's, that haven't heard of the 70's...
#
# Note that gnu touch is stupid, and warns about the syntax; thus the
# redirect of stderr.
precompile.sh-stamp: precompile.sh
	@touch 0101010185 precompile.sh-stamp 2>/dev/null

$(SRCDIR)/machine.h.in: $(SRCDIR)/stamp-h.in
	@if test -f $(SRCDIR)/machine.h.in; then :; else \
	  rm $(SRCDIR)/stamp-h.in; $(MAKE) $(SRCDIR)/stamp-h.in; \
	fi

machine.h: stamp-h
	@if test -f machine.h; then :; else \
	  rm stamp-h; $(MAKE) stamp-h; \
	fi

stamp-h: $(SRCDIR)/stamp-h.in $(SRCDIR)/machine.h.in config.status
	-@(while :; do \
	  echo foo > cfl.$@; test "`echo cfl.*`" = cfl.$@ && break; \
	  rm cfl.$@; echo "Waiting to run config.status serially:" cfl.*; sleep 1; \
	  arb=31; while test $$arb != 0; do arb=`expr $$arb - 1`; done; \
	done;)
	CONFIG_FILES="" CONFIG_HEADERS=machine.h ./config.status || \
	  (EXITCODE=$$?; rm cfl.$@; exit $$EXITCODE)
	touch stamp-h
	-@rm cfl.$@

testsuite: $(SRCDIR)/testsuite.in $(TMP_BINDIR)/mktestsuite
	if test "$$PIKE_PATH_TRANSLATE" = ""; then \
	  $(TMP_BINDIR)/mktestsuite $(SRCDIR)/testsuite.in >testsuite \
	    -DSRCDIR="$(SRCDIR)"; \
	else \
	  $(TMP_BINDIR)/mktestsuite $(SRCDIR)/testsuite.in >testsuite \
	    -DSRCDIR="`echo $(SRCDIR)|sed -e $$PIKE_PATH_TRANSLATE`"; \
	fi

header_uncompress: $(SRCDIR)/uncompressor.c
	$(CC) -O2 -static  $(SRCDIR)/uncompressor.c -o header_uncompress -lz

uncompress_header: $(SRCDIR)/uncompressor.c header_uncompress
	$(CC) -O2 -static  $(SRCDIR)/uncompressor.c -o uncompress_header -lz -DSEEK_TO=`wc -c header_uncompress|sed 's/[^0-9]//g'`
	test "`wc -c header_uncompress|sed 's/[^0-9]//g'`" = "`wc -c uncompress_header|sed 's/[^0-9]//g'`"

HFILES=						\
  operators.protos					\
  array.protos					\
  fd_control.protos					\
  backend.protos					\
  fdlib.protos					\
  bignum.protos					\
  fsort.protos					\
  pike_memory.protos					\
  pike_types.protos					\
  gc.protos						\
  port.protos					\
  callback.protos					\
  hashtable.protos					\
  program.protos					\
  interpret.protos					\
  constants.protos					\
  language.protos					\
  queue.protos					\
  cpp.protos						\
  rusage.protos					\
  cyclic.protos					\
  lex.protos						\
  security.protos					\
  signal_handler.protos				\
  pike_search.protos				\
  docode.protos					\
  main.protos					\
  stralloc.protos					\
  mapping.protos					\
  stuff.protos					\
  dynamic_buffer.protos				\
  svalue.protos					\
  dynamic_load.protos				\
  module_support.protos				\
  threads.protos					\
  multiset.protos					\
  encode.protos					\
  object.protos					\
  error.protos					\
  opcodes.protos					\
  version.protos                                    \
  builtin.protos					\
  iterators.protos				\
  rbtree.protos

$(HFILES): precompile.sh-stamp

import-stamp: $(HFILES) precompile.sh-stamp
	@./precompile.sh fake_dynamic_load.pike >import_functions.tmp $(HFILES)
	@cmp import_functions.tmp import_functions.h >/dev/null || mv import_functions.tmp import_functions.h
	@echo hej >import-stamp

import_functions.h: import-stamp
	test -f import-stamp || ( rm import-stamp ; $(MAKE) import-stamp )

export_functions.c: import_functions.h
	touch export_functions.c

module.o: post_modules/modlist.h post_modules/modlist_headers.h 

# Must have manual depends on all the bytecode methods in the code
# dir, since make depend will only include the one that was chosen,
# and that doesn't suffice in source dists.

$(SRCDIR)/pikecode.h: \
  $(SRCDIR)/code/ia32.h \
  $(SRCDIR)/code/sparc.h \
  $(SRCDIR)/code/ppc32.h \
  $(SRCDIR)/code/computedgoto.h \
  $(SRCDIR)/code/bytecode.h
	touch $(SRCDIR)/pikecode.h

$(SRCDIR)/pikecode.c: \
  $(SRCDIR)/code/ia32.c \
  $(SRCDIR)/code/sparc.c \
  $(SRCDIR)/code/ppc32.c \
  $(SRCDIR)/code/computedgoto.c \
  $(SRCDIR)/code/bytecode.c
	touch $(SRCDIR)/pikecode.c

@dependencies@

