805 lines
22 KiB
Makefile
805 lines
22 KiB
Makefile
# 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". This changes the install procedure so it installs the
|
|
# Python binary as "python<version>". The libraries and include files
|
|
# are always installed in a subdirectory called "python<version>".
|
|
# "make altinstall" does not install the manual page. If you want to
|
|
# make this installation the "official" installation but want to keep
|
|
# the old binary around "just in case", rename the installed python
|
|
# binary to "python<oldversion>" before running "make install".
|
|
# (This only works between different versions, e.g. 1.3 and 1.4 --
|
|
# different betas of the same version will overwrite each other in
|
|
# installation unless you override the VERSION Make variable.)
|
|
#
|
|
# In fact, "make install" or "make bininstall" installs the binary
|
|
# as python<version> and makes a hard link to python, so when
|
|
# installing a new version in the future, nothing of the current
|
|
# version will be lost (except for the man page).
|
|
#
|
|
# 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_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) -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) $(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@
|
|
DESTSHARED= $(BINLIBDEST)/lib-dynload
|
|
|
|
# Executable suffix (.exe on Windows and Mac OS X)
|
|
EXEEXT= @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
|
|
|
|
# --with-PACKAGE options for configure script
|
|
# e.g. --with-readline --with-svr5 --with-solaris --with-thread
|
|
# (see README for an explanation)
|
|
WITH=
|
|
|
|
|
|
# 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@
|
|
|
|
PYTHON= python$(EXEEXT)
|
|
|
|
# === Definitions added by makesetup ===
|
|
|
|
|
|
##########################################################################
|
|
# Modules
|
|
MODULE_OBJS= \
|
|
Modules/config.o \
|
|
Modules/getpath.o \
|
|
Modules/main.o \
|
|
Modules/getbuildinfo.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$(EXEEXT)
|
|
|
|
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/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/sysmodule.o \
|
|
Python/traceback.o \
|
|
Python/getopt.o \
|
|
Python/$(DYNLOADFILE) \
|
|
$(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/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= \
|
|
$(PARSER_OBJS) \
|
|
$(OBJECT_OBJS) \
|
|
$(PYTHON_OBJS) \
|
|
$(MODULE_OBJS) \
|
|
$(SIGNAL_OBJS) \
|
|
$(MODOBJS)
|
|
|
|
|
|
#########################################################################
|
|
# Rules
|
|
|
|
# Default target
|
|
all: $(PYTHON) sharedmods
|
|
|
|
# Build the interpreter
|
|
$(PYTHON): $(MAINOBJ) $(LDLIBRARY)
|
|
expr `cat buildno` + 1 >buildno1
|
|
mv -f buildno1 buildno
|
|
$(LINKCC) $(LDFLAGS) $(LINKFORSHARED) -o $@ $(MAINOBJ) \
|
|
$(LDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST)
|
|
|
|
buildno:
|
|
echo 1 >buildno
|
|
|
|
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)
|
|
./$(PYTHON) $(srcdir)/setup.py build
|
|
|
|
# Build static library
|
|
$(LIBRARY): $(LIBRARY_OBJS)
|
|
-rm -f $@
|
|
# avoid long command lines, same as LIBRARY_OBJS
|
|
$(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) \
|
|
$(srcdir)/BeOS/ar-fake 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 $@ $<
|
|
|
|
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 $@ $<
|
|
|
|
Modules/ccpython.o: Modules/ccpython.cc
|
|
$(CXX) -c $(PY_CFLAGS) -o $@ $<
|
|
|
|
|
|
$(GRAMMAR_H) $(GRAMMAR_C): $(PGEN) $(GRAMMAR_INPUT)
|
|
$(PGEN) $(GRAMMAR_INPUT)
|
|
mv graminit.h $(GRAMMAR_H)
|
|
mv graminit.c $(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/getplatform.o: $(srcdir)/Python/getplatform.c
|
|
$(CC) -c $(CFLAGS) -DPLATFORM='"$(MACHDEP)"' -o $@ $<
|
|
|
|
Python/importdl.o: $(srcdir)/Python/importdl.c
|
|
$(CC) -c $(CFLAGS) -I$(DLINCLDIR) -o $@ $<
|
|
|
|
|
|
Objects/unicodectype.o: $(srcdir)/Objects/unicodectype.c \
|
|
$(srcdir)/Objects/unicodetype_db.h
|
|
|
|
|
|
############################################################################
|
|
# 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/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/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) $(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
|
|
-rm -f $(srcdir)/Lib/test/*.py[co]
|
|
-PYTHONPATH= $(TESTPYTHON) $(TESTPROG) $(TESTOPTS)
|
|
PYTHONPATH= $(TESTPYTHON) $(TESTPROG) $(TESTOPTS)
|
|
|
|
# Install everything
|
|
install: altinstall bininstall maninstall
|
|
|
|
# Install almost everything without disturbing previous versions
|
|
altinstall: altbininstall libinstall inclinstall libainstall sharedinstall
|
|
|
|
# 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 $(INSTALL_SHARED) $$i $(DESTSHARED)/$$i; \
|
|
fi; \
|
|
done
|
|
|
|
$(DESTSHARED):
|
|
@for i in $(DESTDIRS); \
|
|
do \
|
|
if test ! -d $$i; then \
|
|
echo "Creating directory $$i"; \
|
|
$(INSTALL) -d 755 $$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)$(EXEEXT) python$(EXEEXT))
|
|
|
|
# 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 $(DIRMODE) $$i; \
|
|
else true; \
|
|
fi; \
|
|
done
|
|
$(INSTALL_PROGRAM) $(PYTHON) $(BINDIR)/python$(VERSION)$(EXEEXT)
|
|
if test -f libpython$(VERSION).so; then \
|
|
$(INSTALL_DATA) libpython$(VERSION).so $(LIBDIR); \
|
|
else true; \
|
|
fi
|
|
if test -f "$(DLLLIBRARY)"; then \
|
|
$(INSTALL_DATA) $(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 $(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 $(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 $(DIRMODE) $$b; \
|
|
else true; \
|
|
fi; \
|
|
done
|
|
@for i in $(srcdir)/Lib/*.py $(srcdir)/Lib/*.doc; \
|
|
do \
|
|
if test -x $$i; then \
|
|
$(INSTALL_PROGRAM) $$i $(LIBDEST); \
|
|
echo $(INSTALL_PROGRAM) $$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_PROGRAM) $$i $$b; \
|
|
$(INSTALL_PROGRAM) $$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 $(LIBDEST)
|
|
PYTHONPATH=$(LIBDEST) \
|
|
./$(PYTHON) -O $(LIBDEST)/compileall.py $(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 EXEEXT; EXEEXT="$(EXEEXT)"; \
|
|
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 $(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 $(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/python.o $(LIBPL)/python.o
|
|
$(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_PROGRAM) $(srcdir)/Modules/makesetup $(LIBPL)/makesetup
|
|
$(INSTALL_PROGRAM) $(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_PROGRAM) $(srcdir)/Modules/makexp_aix \
|
|
$(LIBPL)/makexp_aix; \
|
|
echo "$(LIBPL)/makexp_aix"; \
|
|
$(INSTALL_PROGRAM) $(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) BeOS/README $(LIBPL)/README; \
|
|
echo; echo "$(LIBPL)/README"; \
|
|
$(INSTALL_DATA) BeOS/README.readline-2.2 $(LIBPL)/README.readline-2.2; \
|
|
echo "$(LIBPL)/README.readline-2.2"; \
|
|
$(INSTALL_PROGRAM) BeOS/ar-fake $(LIBPL)/ar-fake; \
|
|
echo "$(LIBPL)/ar-fake"; \
|
|
$(INSTALL_PROGRAM) BeOS/linkmodule $(LIBPL)/linkmodule; \
|
|
echo "$(LIBPL)/linkmodule"; \
|
|
echo; echo "See BeOS/README for details."; \
|
|
;; \
|
|
esac
|
|
|
|
# Install the dynamically loadable modules
|
|
# This goes into $(exec_prefix)
|
|
sharedinstall:
|
|
./python$(EXE) $(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. If config.status already exists,
|
|
# call it with the --recheck argument, which reruns configure with the
|
|
# same options as it was run last time; otherwise run the configure
|
|
# script with options taken from the $(WITH) variable
|
|
config.status: $(srcdir)/configure
|
|
if test -f config.status; \
|
|
then $(SHELL) config.status --recheck; \
|
|
$(SHELL) config.status; \
|
|
else $(SHELL) $(srcdir)/configure $(WITH); \
|
|
fi
|
|
|
|
.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:
|
|
-rm -f core *~ [@,#]* *.old *.orig *.rej
|
|
-rm -rf build
|
|
# avoid long command lines, same as LIBRARY_OBJS MAINOBJ PGOBJS
|
|
-rm -f $(PARSER_OBJS)
|
|
-rm -f $(OBJECT_OBJS)
|
|
-rm -f $(PYTHON_OBJS)
|
|
-rm -f $(MODULE_OBJS) $(SIGNAL_OBJS)
|
|
-rm -f $(MODOBJS) $(MAINOBJ) $(PGOBJS)
|
|
|
|
clobber: clean
|
|
-rm -f tags TAGS $(PYTHON) $(LIBRARY) $(LDLIBRARY) $(DLLLIBRARY) \
|
|
Modules/*.so Modules/*.sl
|
|
|
|
# Make things extra clean, before making a distribution:
|
|
# remove all generated files, even Makefile[.pre]
|
|
distclean: clobber
|
|
-rm -f Makefile Makefile.pre buildno config.status config.log \
|
|
config.cache config.h setup.cfg Modules/config.c \
|
|
Modules/Setup Modules/Setup.local Modules/Setup.config
|
|
-for i in $(SUBDIRSTOO); do \
|
|
for f in $$i/*.in; do \
|
|
f=`basename "$$f" .in`; \
|
|
if test "$$f" != "*"; then \
|
|
echo rm -f "$$i/$$f"; \
|
|
rm -f "$$i/$$f"; \
|
|
fi; \
|
|
done; \
|
|
done
|
|
|
|
# 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
|