# Top-level Makefile for Python

#

# As distributed, this file is called Makefile.pre.in; it is processed

# into the real Makefile by running the script ./configure, which

# replaces things like @spam@ with values appropriate for your system.

# This means that if you edit Makefile, your changes get lost the next

# time you run the configure script. Ideally, you can do:

#

# ./configure

# make

# make test

# make install

#

# If you have a previous version of Python installed that you don't

# want to overwrite, you can use "make altinstall" instead of "make

# install". Refer to the "Installing" section in the README file for

# additional details.

#

# See also the section "Build instructions" in the README file.

# === Variables set by makesetup ===

MODOBJS= _MODOBJS_

MODLIBS= _MODLIBS_

# === Variables set by configure

VERSION= @VERSION@

srcdir= @srcdir@

VPATH= @srcdir@

CC= @CC@

CXX= @CXX@

LINKCC= @LINKCC@

AR= @AR@

RANLIB= @RANLIB@

# Shell used by make (some versions default to the login shell, which is bad)

SHELL= /bin/sh

# Use this to make a link between python$(VERSION) and python in $(BINDIR)

LN= @LN@

# Portable install script (configure doesn't always guess right)

INSTALL= @INSTALL@

INSTALL_PROGRAM=@INSTALL_PROGRAM@

INSTALL_SCRIPT= @INSTALL_SCRIPT@

INSTALL_DATA= @INSTALL_DATA@

# Shared libraries must be installed with executable mode on some systems;

# rather than figuring out exactly which, we always give them executable mode.

# Also, making them read-only seems to be a good idea...

INSTALL_SHARED= ${INSTALL} -m 555

MAKESETUP= $(srcdir)/Modules/makesetup

# Compiler options

OPT= @OPT@

DEFS= @DEFS@

CFLAGS= $(OPT)

CPPFLAGS= -I. -I$(srcdir)/Include $(DEFS)

LDFLAGS= @LDFLAGS@

LDLAST= @LDLAST@

SGI_ABI= @SGI_ABI@

CCSHARED= @CCSHARED@

LINKFORSHARED= @LINKFORSHARED@

# Extra C flags added for building the interpreter object files.

CFLAGSFORSHARED=@CFLAGSFORSHARED@

# C flags used for building the interpreter object files

PY_CFLAGS= $(CFLAGS) $(CPPFLAGS) $(CFLAGSFORSHARED)

# Machine-dependent subdirectories

MACHDEP= @MACHDEP@

# Install prefix for architecture-independent files

prefix= @prefix@

# Install prefix for architecture-dependent files

exec_prefix= @exec_prefix@

# Expanded directories

BINDIR= $(exec_prefix)/bin

LIBDIR= $(exec_prefix)/lib

MANDIR= $(prefix)/man

INCLUDEDIR= $(prefix)/include

CONFINCLUDEDIR= $(exec_prefix)/include

SCRIPTDIR= $(prefix)/lib

# Detailed destination directories

BINLIBDEST= $(LIBDIR)/python$(VERSION)

LIBDEST= $(SCRIPTDIR)/python$(VERSION)

INCLUDEPY= $(INCLUDEDIR)/python$(VERSION)

CONFINCLUDEPY= $(CONFINCLUDEDIR)/python$(VERSION)

LIBP= $(LIBDIR)/python$(VERSION)

# Symbols used for using shared libraries

SO= @SO@

LDSHARED= @LDSHARED@

BLDSHARED= @BLDSHARED@

DESTSHARED= $(BINLIBDEST)/lib-dynload

# Executable suffix (.exe on Windows and Mac OS X)

EXE= @EXEEXT@

# Modes for directories, executables and data files created by the

# install process. Default to user-only-writable for all file types.

DIRMODE= 755

EXEMODE= 755

FILEMODE= 644

# configure script arguments

CONFIG_ARGS= @CONFIG_ARGS@

# Subdirectories with code

SRCDIRS= @SRCDIRS@

# Other subdirectories

SUBDIRSTOO= Include Lib Misc Demo

# Files and directories to be distributed

CONFIGFILES= configure configure.in acconfig.h config.h.in Makefile.pre.in

DISTFILES= README ChangeLog $(CONFIGFILES)

DISTDIRS= $(SUBDIRS) $(SUBDIRSTOO) Ext-dummy

DIST= $(DISTFILES) $(DISTDIRS)

LIBRARY= @LIBRARY@

LDLIBRARY= @LDLIBRARY@

DLLLIBRARY= @DLLLIBRARY@

LIBS= @LIBS@

LIBM= @LIBM@

LIBC= @LIBC@

SYSLIBS= $(LIBM) $(LIBC)

MAINOBJ= @MAINOBJ@

LIBOBJS= @LIBOBJS@

DLINCLDIR= @DLINCLDIR@

DYNLOADFILE= @DYNLOADFILE@

MACHDEP_OBJS= @MACHDEP_OBJS@

PYTHON= python$(EXE)

# === Definitions added by makesetup ===

##########################################################################

# Modules

MODULE_OBJS= \

Modules/config.o \

Modules/getpath.o \

Modules/main.o

# Used of signalmodule.o is not available

SIGNAL_OBJS= @SIGNAL_OBJS@

##########################################################################

# Grammar

GRAMMAR_H= $(srcdir)/Include/graminit.h

GRAMMAR_C= $(srcdir)/Python/graminit.c

GRAMMAR_INPUT= $(srcdir)/Grammar/Grammar

##########################################################################

# Parser

PGEN= Parser/pgen$(EXE)

POBJS= \

Parser/acceler.o \

Parser/grammar1.o \

Parser/listnode.o \

Parser/node.o \

Parser/parser.o \

Parser/parsetok.o \

Parser/tokenizer.o \

Parser/bitset.o \

Parser/metagrammar.o

PARSER_OBJS= $(POBJS) Parser/myreadline.o

PGOBJS= \

Parser/firstsets.o \

Parser/grammar.o \

Parser/pgen.o \

Parser/printgrammar.o \

Parser/pgenmain.o

PGENOBJS= $(PGENMAIN) $(POBJS) $(PGOBJS)

##########################################################################

# Python

PYTHON_OBJS= \

Python/bltinmodule.o \

Python/exceptions.o \

Python/ceval.o \

Python/compile.o \

Python/codecs.o \

Python/errors.o \

Python/frozen.o \

Python/frozenmain.o \

Python/future.o \

Python/getargs.o \

Python/getcompiler.o \

Python/getcopyright.o \

Python/getmtime.o \

Python/getplatform.o \

Python/getversion.o \

Python/graminit.o \

Python/import.o \

Python/importdl.o \

Python/marshal.o \

Python/modsupport.o \

Python/mystrtoul.o \

Python/pyfpe.o \

Python/pystate.o \

Python/pythonrun.o \

Python/structmember.o \

Python/symtable.o \

Python/sysmodule.o \

Python/traceback.o \

Python/getopt.o \

Python/$(DYNLOADFILE) \

$(MACHDEP_OBJS) \

$(LIBOBJS)

##########################################################################

# Objects

OBJECT_OBJS= \

Objects/abstract.o \

Objects/bufferobject.o \

Objects/cellobject.o \

Objects/classobject.o \

Objects/cobject.o \

Objects/complexobject.o \

Objects/fileobject.o \

Objects/floatobject.o \

Objects/frameobject.o \

Objects/funcobject.o \

Objects/intobject.o \

Objects/iterobject.o \

Objects/listobject.o \

Objects/longobject.o \

Objects/dictobject.o \

Objects/methodobject.o \

Objects/moduleobject.o \

Objects/object.o \

Objects/rangeobject.o \

Objects/sliceobject.o \

Objects/stringobject.o \

Objects/tupleobject.o \

Objects/typeobject.o \

Objects/unicodeobject.o \

Objects/unicodectype.o

##########################################################################

# objects that get linked into the Python library

LIBRARY_OBJS= \

Modules/getbuildinfo.o \

$(PARSER_OBJS) \

$(OBJECT_OBJS) \

$(PYTHON_OBJS) \

$(MODULE_OBJS) \

$(SIGNAL_OBJS) \

$(MODOBJS)

#########################################################################

# Rules

# Default target

all: $(PYTHON) oldsharedmods sharedmods

# Build the interpreter

$(PYTHON): Modules/$(MAINOBJ) $(LDLIBRARY)

$(LINKCC) $(LDFLAGS) $(LINKFORSHARED) -o $@ \

Modules/$(MAINOBJ) \

$(LDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST)

platform: $(PYTHON)

./$(PYTHON) -c 'import sys ; from distutils.util import get_platform ; print get_platform()+"-"+sys.version[0:3]' >platform

# Build the shared modules

sharedmods: $(PYTHON)

PYTHONPATH= ./$(PYTHON) $(srcdir)/setup.py build

# buildno should really depend on something like LIBRARY_SRC

buildno: $(PARSER_OBJS) \

$(OBJECT_OBJS) \

$(PYTHON_OBJS) \

$(MODULE_OBJS) \

$(SIGNAL_OBJS) \

$(MODOBJS) \

$(srcdir)/Modules/getbuildinfo.c

if test -f buildno; then \

expr `cat buildno` + 1 >buildno1; \

mv -f buildno1 buildno; \

else echo 1 >buildno; fi

# Build static library

# avoid long command lines, same as LIBRARY_OBJS

$(LIBRARY): $(LIBRARY_OBJS)

-rm -f $@

$(AR) cr $@ Modules/getbuildinfo.o

$(AR) cr $@ $(PARSER_OBJS)

$(AR) cr $@ $(OBJECT_OBJS)

$(AR) cr $@ $(PYTHON_OBJS)

$(AR) cr $@ $(MODULE_OBJS) $(SIGNAL_OBJS)

$(AR) cr $@ $(MODOBJS)

$(RANLIB) $@

# This rule is only here for DG/UX and BeOS!!!

libpython$(VERSION).so: $(LIBRARY)

case `uname -s | tr -d '/ ' | tr '[A-Z]' '[a-z]'` in \

*dgux*) \

test -d dgux || mkdir dgux; \

(cd dgux;ar x ../$^;ld -G -o ../$@ * ); \

/bin/rm -rf ./dgux \

;; \

beos) \

$(AR) so $(LIBRARY) $@ \

;; \

esac

# This rule is here for OPENSTEP/Rhapsody/MacOSX

libpython$(VERSION).dylib: $(LIBRARY)

libtool -o $(LDLIBRARY) -dynamic $(OTHER_LIBTOOL_OPT) $(LIBRARY) \

-framework System @LIBTOOL_CRUFT@

# This rule builds the Cygwin Python DLL

libpython$(VERSION).dll.a: $(LIBRARY_OBJS)

dlltool --export-all --output-def $@ $^

$(LDSHARED) -Wl,--out-implib=$@ -o $(DLLLIBRARY) $^ \

$(LIBS) $(MODLIBS) $(SYSLIBS)

oldsharedmods: $(SHAREDMODS)

Makefile Modules/config.c: Makefile.pre \

$(srcdir)/Modules/config.c.in \

$(MAKESETUP) \

Modules/Setup.config \

Modules/Setup \

Modules/Setup.local

$(SHELL) $(MAKESETUP) -c $(srcdir)/Modules/config.c.in \

-s Modules \

Modules/Setup.config \

Modules/Setup.local \

Modules/Setup

@mv config.c Modules

@echo "The Makefile was updated, you may need to re-run make."

Modules/Setup: $(srcdir)/Modules/Setup.dist

@if test -f Modules/Setup; then \

echo "-----------------------------------------------"; \

echo "Modules/Setup.dist is newer than Modules/Setup;"; \

echo "check to make sure you have all the updates you"; \

echo "need in your Modules/Setup file."; \

echo "-----------------------------------------------"; \

fi

############################################################################

# Special rules for object files

Modules/getbuildinfo.o: $(srcdir)/Modules/getbuildinfo.c buildno

$(CC) -c $(PY_CFLAGS) -DBUILD=`cat buildno` -o $@ $(srcdir)/Modules/getbuildinfo.c

Modules/getpath.o: $(srcdir)/Modules/getpath.c Makefile

$(CC) -c $(PY_CFLAGS) -DPYTHONPATH='"$(PYTHONPATH)"' \

-DPREFIX='"$(prefix)"' \

-DEXEC_PREFIX='"$(exec_prefix)"' \

-DVERSION='"$(VERSION)"' \

-DVPATH='"$(VPATH)"' \

-o $@ $(srcdir)/Modules/getpath.c

Modules/ccpython.o: $(srcdir)/Modules/ccpython.cc

$(CXX) -c $(PY_CFLAGS) -o $@ $(srcdir)/Modules/ccpython.cc

$(GRAMMAR_H) $(GRAMMAR_C): $(PGEN) $(GRAMMAR_INPUT)

-$(PGEN) $(GRAMMAR_INPUT) $(GRAMMAR_H) $(GRAMMAR_C)

$(PGEN): $(PGENOBJS)

$(CC) $(OPT) $(PGENOBJS) $(LIBS) -o $(PGEN)

Parser/grammar.o: $(srcdir)/Parser/grammar.c \

$(srcdir)/Parser/assert.h \

$(srcdir)/Include/token.h \

$(srcdir)/Include/grammar.h

Parser/metagrammar.o: $(srcdir)/Parser/metagrammar.c

Python/compile.o Python/symtable.o: $(GRAMMAR_H)

Python/getplatform.o: $(srcdir)/Python/getplatform.c

$(CC) -c $(CFLAGS) $(CPPFLAGS) -DPLATFORM='"$(MACHDEP)"' -o $@ $(srcdir)/Python/getplatform.c

Python/importdl.o: $(srcdir)/Python/importdl.c

$(CC) -c $(CFLAGS) $(CPPFLAGS) -I$(DLINCLDIR) -o $@ $(srcdir)/Python/importdl.c

Objects/object.o: $(srcdir)/Objects/object.c $(srcdir)/Objects/obmalloc.c

Objects/unicodectype.o: $(srcdir)/Objects/unicodectype.c \

$(srcdir)/Objects/unicodetype_db.h

Mac/Python/macglue.o: $(srcdir)/Mac/Python/macglue.c

$(CC) -c $(CFLAGS) $(CPPFLAGS) -I$(srcdir)/Mac/Include -I$(srcdir)/Python -o $@ $(srcdir)/Mac/Python/macglue.c

############################################################################

# Header files

PYTHON_HEADERS= \

Include/Python.h \

config.h \

Include/patchlevel.h \

Include/pyport.h \

Include/pymem.h \

Include/object.h \

Include/objimpl.h \

Include/compile.h \

Include/symtable.h \

Include/pydebug.h \

Include/unicodeobject.h \

Include/intobject.h \

Include/longobject.h \

Include/floatobject.h \

Include/complexobject.h \

Include/rangeobject.h \

Include/stringobject.h \

Include/bufferobject.h \

Include/tupleobject.h \

Include/listobject.h \

Include/iterobject.h \

Include/dictobject.h \

Include/methodobject.h \

Include/moduleobject.h \

Include/funcobject.h \

Include/classobject.h \

Include/fileobject.h \

Include/cobject.h \

Include/traceback.h \

Include/sliceobject.h \

Include/codecs.h \

Include/pyerrors.h \

Include/pystate.h \

Include/modsupport.h \

Include/ceval.h \

Include/pythonrun.h \

Include/sysmodule.h \

Include/intrcheck.h \

Include/import.h \

Include/abstract.h \

Include/pyfpe.h

$(LIBRARY_OBJS) $(MODOBJS) Modules/$(MAINOBJ): $(PYTHON_HEADERS)

######################################################################

# Test the interpreter (twice, once without .pyc files, once with)

TESTOPTS= -l

TESTPROG= $(srcdir)/Lib/test/regrtest.py

TESTPYTHON= ./$(PYTHON) -tt

test: all platform

-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f

-PYTHONPATH= $(TESTPYTHON) $(TESTPROG) $(TESTOPTS)

PYTHONPATH= $(TESTPYTHON) $(TESTPROG) $(TESTOPTS)

QUICKTESTOPTS= $(TESTOPTS) -x test_thread test_signal test_strftime \

test_unicodedata test_re test_sre test_select test_poll \

test_linuxaudiodev test_sunaudiodev

quicktest: all platform

-find $(srcdir)/Lib -name '*.py[co]' -print | xargs rm -f

-PYTHONPATH= $(TESTPYTHON) $(TESTPROG) $(QUICKTESTOPTS)

PYTHONPATH= $(TESTPYTHON) $(TESTPROG) $(QUICKTESTOPTS)

MEMTESTOPTS= $(QUICKTESTOPTS) -x test_dl test___all__ test_fork1 \

test_longexp

memtest: all platform

-rm -f $(srcdir)/Lib/test/*.py[co]

-PYTHONPATH= $(TESTPYTHON) $(TESTPROG) $(MEMTESTOPTS)

PYTHONPATH= $(TESTPYTHON) $(TESTPROG) $(MEMTESTOPTS)

# Install everything

install: altinstall bininstall maninstall

# Install almost everything without disturbing previous versions

altinstall: altbininstall libinstall inclinstall libainstall \

sharedinstall oldsharedinstall

# Install shared libraries enabled by Setup

DESTDIRS= $(exec_prefix) $(LIBDIR) $(BINLIBDEST) $(DESTSHARED)

oldsharedinstall: $(DESTSHARED) $(SHAREDMODS)

@for i in X $(SHAREDMODS); do \

if test $$i != X; then \

echo $(INSTALL_SHARED) $$i $(DESTSHARED)/`basename $$i`; \

$(INSTALL_SHARED) $$i $(DESTSHARED)/`basename $$i`; \

fi; \

done

$(DESTSHARED):

@for i in $(DESTDIRS); \

do \

if test ! -d $$i; then \

echo "Creating directory $$i"; \

$(INSTALL) -d -m $(DIRMODE) $$i; \

else true; \

fi; \

done

# Install the interpreter (by creating a hard link to python$(VERSION))

bininstall: altbininstall

-if test -f $(BINDIR)/$(PYTHON); \

then rm -f $(BINDIR)/$(PYTHON); \

else true; \

fi

(cd $(BINDIR); $(LN) python$(VERSION)$(EXE) $(PYTHON))

# Install the interpreter with $(VERSION) affixed

# This goes into $(exec_prefix)

altbininstall: $(PYTHON)

@for i in $(BINDIR); \

do \

if test ! -d $$i; then \

echo "Creating directory $$i"; \

$(INSTALL) -d -m $(DIRMODE) $$i; \

else true; \

fi; \

done

$(INSTALL_PROGRAM) $(PYTHON) $(BINDIR)/python$(VERSION)$(EXE)

if test -f libpython$(VERSION).so; then \

$(INSTALL_DATA) libpython$(VERSION).so $(LIBDIR); \

else true; \

fi

if test -f "$(DLLLIBRARY)"; then \

$(INSTALL_SHARED) $(DLLLIBRARY) $(BINDIR); \

else true; \

fi

# Install the manual page

maninstall:

@for i in $(MANDIR) $(MANDIR)/man1; \

do \

if test ! -d $$i; then \

echo "Creating directory $$i"; \

$(INSTALL) -d -m $(DIRMODE) $$i; \

else true; \

fi; \

done

$(INSTALL_DATA) $(srcdir)/Misc/python.man \

$(MANDIR)/man1/python.1

# Install the library

PLATDIR= plat-$(MACHDEP)

MACHDEPS= $(PLATDIR)

XMLLIBSUBDIRS= xml xml/dom xml/parsers xml/sax

LIBSUBDIRS= lib-old lib-tk site-packages test test/output encodings \

distutils distutils/command $(XMLLIBSUBDIRS) curses $(MACHDEPS)

libinstall: $(PYTHON) $(srcdir)/Lib/$(PLATDIR)

@for i in $(SCRIPTDIR) $(LIBDEST); \

do \

if test ! -d $$i; then \

echo "Creating directory $$i"; \

$(INSTALL) -d -m $(DIRMODE) $$i; \

else true; \

fi; \

done

@for d in $(LIBSUBDIRS); \

do \

a=$(srcdir)/Lib/$$d; \

if test ! -d $$a; then continue; else true; fi; \

b=$(LIBDEST)/$$d; \

if test ! -d $$b; then \

echo "Creating directory $$b"; \

$(INSTALL) -d -m $(DIRMODE) $$b; \

else true; \

fi; \

done

@for i in $(srcdir)/Lib/*.py $(srcdir)/Lib/*.doc; \

do \

if test -x $$i; then \

$(INSTALL_SCRIPT) $$i $(LIBDEST); \

echo $(INSTALL_SCRIPT) $$i $(LIBDEST); \

else \

$(INSTALL_DATA) $$i $(LIBDEST); \

echo $(INSTALL_DATA) $$i $(LIBDEST); \

fi; \

done

@for d in $(LIBSUBDIRS); \

do \

a=$(srcdir)/Lib/$$d; \

if test ! -d $$a; then continue; else true; fi; \

b=$(LIBDEST)/$$d; \

for i in $$a/*; \

do \

case $$i in \

*CVS) ;; \

*.py[co]) ;; \

*.orig) ;; \

*~) ;; \

*) \

if test -d $$i; then continue; fi; \

if test -x $$i; then \

echo $(INSTALL_SCRIPT) $$i $$b; \

$(INSTALL_SCRIPT) $$i $$b; \

else \

echo $(INSTALL_DATA) $$i $$b; \

$(INSTALL_DATA) $$i $$b; \

fi;; \

esac; \

done; \

done

$(INSTALL_DATA) $(srcdir)/LICENSE $(LIBDEST)/LICENSE.txt

PYTHONPATH=$(LIBDEST) \

./$(PYTHON) -tt $(LIBDEST)/compileall.py -x badsyntax \

$(LIBDEST)

PYTHONPATH=$(LIBDEST) \

./$(PYTHON) -O $(LIBDEST)/compileall.py -x badsyntax $(LIBDEST)

# Create the PLATDIR source directory, if one wasn't distributed..

$(srcdir)/Lib/$(PLATDIR):

mkdir $(srcdir)/Lib/$(PLATDIR)

cp $(srcdir)/Lib/plat-generic/regen $(srcdir)/Lib/$(PLATDIR)/regen

export PATH; PATH="`pwd`:$$PATH"; \

export PYTHONPATH; PYTHONPATH="`pwd`/Lib"; \

export EXE; EXE="$(EXE)"; \

cd $(srcdir)/Lib/$(PLATDIR); ./regen

# Install the include files

INCLDIRSTOMAKE=$(INCLUDEDIR) $(CONFINCLUDEDIR) $(INCLUDEPY) $(CONFINCLUDEPY)

inclinstall:

@for i in $(INCLDIRSTOMAKE); \

do \

if test ! -d $$i; then \

echo "Creating directory $$i"; \

$(INSTALL) -d -m $(DIRMODE) $$i; \

else true; \

fi; \

done

@for i in $(srcdir)/Include/*.h; \

do \

echo $(INSTALL_DATA) $$i $(INCLUDEPY); \

$(INSTALL_DATA) $$i $(INCLUDEPY); \

done

$(INSTALL_DATA) config.h $(CONFINCLUDEPY)/config.h

# Install the library and miscellaneous stuff needed for extending/embedding

# This goes into $(exec_prefix)

LIBPL= $(LIBP)/config

libainstall: all

@for i in $(LIBDIR) $(LIBP) $(LIBPL); \

do \

if test ! -d $$i; then \

echo "Creating directory $$i"; \

$(INSTALL) -d -m $(DIRMODE) $$i; \

else true; \

fi; \

done

@if test -d $(LDLIBRARY); then :; else \

$(INSTALL_DATA) $(LDLIBRARY) $(LIBPL)/$(LDLIBRARY) ; \

$(RANLIB) $(LIBPL)/$(LDLIBRARY) ; \

fi

$(INSTALL_DATA) Modules/config.c $(LIBPL)/config.c

$(INSTALL_DATA) Modules/$(MAINOBJ) $(LIBPL)/$(MAINOBJ)

$(INSTALL_DATA) $(srcdir)/Modules/config.c.in $(LIBPL)/config.c.in

$(INSTALL_DATA) Makefile $(LIBPL)/Makefile

$(INSTALL_DATA) Modules/Setup $(LIBPL)/Setup

$(INSTALL_DATA) Modules/Setup.local $(LIBPL)/Setup.local

$(INSTALL_DATA) Modules/Setup.config $(LIBPL)/Setup.config

$(INSTALL_SCRIPT) $(srcdir)/Modules/makesetup $(LIBPL)/makesetup

$(INSTALL_SCRIPT) $(srcdir)/install-sh $(LIBPL)/install-sh

$(INSTALL_DATA) $(srcdir)/Misc/Makefile.pre.in $(LIBPL)/Makefile.pre.in

@if [ -s Modules/python.exp -a \

"`echo $(MACHDEP) | sed 's/^\(...\).*/\1/'`" = "aix" ]; then \

echo; echo "Installing support files for building shared extension modules on AIX:"; \

$(INSTALL_DATA) Modules/python.exp \

$(LIBPL)/python.exp; \

echo; echo "$(LIBPL)/python.exp"; \

$(INSTALL_SCRIPT) $(srcdir)/Modules/makexp_aix \

$(LIBPL)/makexp_aix; \

echo "$(LIBPL)/makexp_aix"; \

$(INSTALL_SCRIPT) $(srcdir)/Modules/ld_so_aix \

$(LIBPL)/ld_so_aix; \

echo "$(LIBPL)/ld_so_aix"; \

echo; echo "See Misc/AIX-NOTES for details."; \

else true; \

fi

@case "$(MACHDEP)" in beos*) \

echo; echo "Installing support files for building shared extension modules on BeOS:"; \

$(INSTALL_DATA) Misc/BeOS-NOTES $(LIBPL)/README; \

echo; echo "$(LIBPL)/README"; \

$(INSTALL_SCRIPT) Modules/ar_beos $(LIBPL)/ar_beos; \

echo "$(LIBPL)/ar_beos"; \

$(INSTALL_SCRIPT) Modules/ld_so_beos $(LIBPL)/ld_so_beos; \

echo "$(LIBPL)/ld_so_beos"; \

echo; echo "See Misc/BeOS-NOTES for details."; \

;; \

esac

# Install the dynamically loadable modules

# This goes into $(exec_prefix)

sharedinstall:

PYTHONPATH= ./$(PYTHON) $(srcdir)/setup.py install \

--install-platlib=$(DESTSHARED)

# Build the toplevel Makefile

Makefile.pre: Makefile.pre.in config.status

CONFIG_FILES=Makefile.pre CONFIG_HEADERS= $(SHELL) config.status

$(MAKE) -f Makefile.pre Makefile

# Run the configure script.

config.status: $(srcdir)/configure

$(SHELL) $(srcdir)/configure $(CONFIG_ARGS)

.PRECIOUS: config.status $(PYTHON) Makefile Makefile.pre

# Some make's put the object file in the current directory

.c.o:

$(CC) -c $(PY_CFLAGS) -o $@ $<

# Rerun configure with the same options as it was run last time,

# provided the config.status script exists

recheck:

$(SHELL) config.status --recheck

$(SHELL) config.status

# Rebuild the configure script from configure.in; also rebuild config.h.in

autoconf:

(cd $(srcdir); autoconf)

(cd $(srcdir); autoheader)

# Create a tags file for vi

tags::

cd $(srcdir); \

ctags -w -t Include/*.h; \

for i in $(SRCDIRS); do ctags -w -t -a $$i/*.[ch]; \

done; \

sort tags -o tags

# Create a tags file for GNU Emacs

TAGS::

cd $(srcdir); \

etags Include/*.h; \

for i in $(SRCDIRS); do etags -a $$i/*.[ch]; done

# Sanitation targets -- clean leaves libraries, executables and tags

# files, which clobber removes those as well

clean:

find . -name '*.o' -exec rm -f {} ';'

find . -name '*.s[ol]' -exec rm -f {} ';'

find $(srcdir) -name '*.py[co]' -exec rm -f {} ';'

clobber: clean

-rm -f $(PYTHON) $(PGEN) $(LIBRARY) $(LDLIBRARY) $(DLLLIBRARY) \

tags TAGS \

config.cache config.log config.h Modules/config.c

-rm -rf build platform

# Make things extra clean, before making a distribution:

# remove all generated files, even Makefile[.pre]

distclean: clobber

-rm -f core Makefile Makefile.pre buildno config.status \

Modules/Setup Modules/Setup.local Modules/Setup.config

find $(srcdir) '(' -name '*.fdc' -o -name '*~' \

-o -name '[@,#]*' -o -name '*.old' \

-o -name '*.orig' -o -name '*.rej' \

-o -name '*.bak' ')' \

-exec rm -f {} ';'

# Check for smelly exported symbols (not starting with Py/_Py)

smelly: all

nm -p $(LIBRARY) | \

sed -n "/ [TDB] /s/.* //p" | grep -v "^_*Py" | sort -u; \

# Find files with funny names

funny:

find $(DISTDIRS) -type d \

-o -name '*.[chs]' \

-o -name '*.py' \

-o -name '*.doc' \

-o -name '*.sty' \

-o -name '*.bib' \

-o -name '*.dat' \

-o -name '*.el' \

-o -name '*.fd' \

-o -name '*.in' \

-o -name '*.tex' \

-o -name '*,[vpt]' \

-o -name 'Setup' \

-o -name 'Setup.*' \

-o -name README \

-o -name Makefile \

-o -name ChangeLog \

-o -name Repository \

-o -name Root \

-o -name Entries \

-o -name Tag \

-o -name tags \

-o -name TAGS \

-o -name .cvsignore \

-o -name MANIFEST \

-o -print

# IF YOU PUT ANYTHING HERE IT WILL GO AWAY