mirror of
https://github.com/python/cpython.git
synced 2025-10-31 05:31:20 +00:00
690 lines
20 KiB
Makefile
690 lines
20 KiB
Makefile
#####################==================----------------
|
|
#
|
|
# Top-Level Makefile for Building Python 2.3 for OS/2 using GCC/EMX
|
|
# Originally written by Andrew Zabolotny, <bit@eltech.ru> for Python 1.5.2
|
|
# Modified by Andrew MacIntyre, <andymac@pcug.org.au> for Python 2.3
|
|
#
|
|
# This makefile was developed for use with [P]GCC/EMX compiler any
|
|
# version and GNU Make.
|
|
#
|
|
# The output of the build is a largish Python23.DLL containing the
|
|
# essential modules of Python and a small Python.exe program to start
|
|
# the interpreter. When embedding Python within another program, only
|
|
# Python23.DLL is needed. We also build python_s.a static library (which
|
|
# can be converted into OMF (.lib) format using emxomf tool) and both
|
|
# python.a and python.lib import libraries. Then the optional
|
|
# extension modules, which are OS/2 DLLs renamed with a PYD file extension.
|
|
#
|
|
# Recommended build order:
|
|
# make depend (if you have makedep)
|
|
# make all
|
|
# make lx (if you have lxlite)
|
|
# make test (optional)
|
|
#
|
|
#####################==================----------------
|
|
|
|
# === Compilation mode: debug or release ===
|
|
MODE= optimize
|
|
#MODE= debug
|
|
# === Assert() enabled ===
|
|
#ASSERTIONS=no
|
|
ASSERTIONS=yes
|
|
|
|
# === Optional modules ===
|
|
# Do you have the InfoZip compression library installed?
|
|
ZLIB= no
|
|
# Do you have the Ultra Fast Crypt (UFC) library installed?
|
|
UFC= no
|
|
# Do you have the Tcl/Tk library installed?
|
|
TCLTK= no
|
|
# Do you have the GNU multiprecision library installed?
|
|
GMPZ= no
|
|
# Do you have the GNU readline library installed?
|
|
# NOTE: I'm using a modified version of Kai Uwe Rommel's port that
|
|
# - is compiled with multithreading enabled
|
|
# - is linked statically
|
|
# I have had no success trying to use a DLL version, even with
|
|
# the multithreading switch.
|
|
GREADLINE= no
|
|
# Do you have the BSD DB library (v1.85) as included in the EMXBSD package?
|
|
# NOTE: this library needs to be recompiled with a structure member
|
|
# renamed to avoid problems with the multithreaded errno support
|
|
# (there is a structure member called errno, used for shadowing the
|
|
# real errno, which conflicts with the errno redefinition of -Zmt)
|
|
BSDDB= no
|
|
# Do you have the ncurses library installed? EMX's BSD curses aren't enough!
|
|
CURSES= no
|
|
# Do you have the GDBM library installed?
|
|
GDBM= no
|
|
# Do you have the BZ2 compression library installed?
|
|
BZ2= no
|
|
|
|
# === The Tools ===
|
|
CC= gcc
|
|
CFLAGS= -Zmt -Wall $(INCLUDE)
|
|
CFLAGS.LIB= $(CFLAGS)
|
|
LD= gcc
|
|
LDFLAGS= -Zmt -Zcrtdll -L. -lgcc
|
|
LDFLAGS.EXE= $(LDFLAGS)
|
|
LDFLAGS.DLL= $(LDFLAGS) -Zdll
|
|
LDFLAGS.A= $(LDFLAGS) $(LIBS)
|
|
ARFLAGS= crs
|
|
IMPLIB= emximp
|
|
EXPLIB= emxexp
|
|
EXEOPT= emxbind
|
|
|
|
|
|
# adjust C compiler settings based on build options
|
|
ifeq ($(MODE),debug)
|
|
CFLAGS+= -g -O
|
|
LDFLAGS+= -g
|
|
else
|
|
CFLAGS+= -s -O2
|
|
LDFLAGS+= -s
|
|
endif
|
|
ifeq ($(ASSERTIONS),no)
|
|
CFLAGS+= -DNDEBUG
|
|
endif
|
|
|
|
# We're using the OMF format since EMX's ld has a obscure bug
|
|
# because of which it sometimes fails to build relocations
|
|
# in .data segment that point to another .data locations
|
|
# (except for the final linking if the .EXEs)
|
|
OMF= yes
|
|
|
|
# if fork() support is required, the main executable must be linked with ld
|
|
EXEOMF= no
|
|
|
|
# File extensions
|
|
MODULE.EXT= .pyd
|
|
ifeq ($(OMF),yes)
|
|
O= .obj
|
|
A= .lib
|
|
AR= emxomfar
|
|
CFLAGS+= -Zomf
|
|
LDFLAGS+= -Zomf
|
|
ifeq ($(MODE),debug)
|
|
ARFLAGS= -p64 crs
|
|
else
|
|
ARFLAGS= -p32 crs
|
|
endif
|
|
else
|
|
O= .o
|
|
A= .a
|
|
AR= ar
|
|
endif
|
|
|
|
# EMX's default number of file handles is 40, which is sometimes insufficient
|
|
# (the tempfile regression test tries to create 100 temporary files)
|
|
NFILES=250
|
|
|
|
# Source file paths
|
|
SRCPATH=.;../../Python;../../Parser;../../Objects;../../Include;../../Modules
|
|
# Python contains the central core, containing the builtins and interpreter.
|
|
# Parser contains Python's Internal Parser and
|
|
# Standalone Parser Generator Program (Shares Some of Python's Modules)
|
|
# Objects contains Python Object Types
|
|
# Modules contains extension Modules (Built-In or as Separate DLLs)
|
|
|
|
# Unix shells tend to use "$" as delimiter for variable names.
|
|
# Test for this behaviour and set $(BUCK) variable correspondigly ...
|
|
__TMP__:=$(shell echo $$$$)
|
|
ifeq ($(__TMP__),$$$$)
|
|
BUCK= $$
|
|
BRO= (
|
|
BRC= )
|
|
else
|
|
BUCK= \$$
|
|
BRO= \(
|
|
BRC= \)
|
|
endif
|
|
# Compute the "double quote" variable
|
|
__TMP__:=$(shell echo "")
|
|
ifeq ($(__TMP__),"")
|
|
DQUOTE= "
|
|
else
|
|
DQUOTE= \"
|
|
endif
|
|
|
|
# Include paths
|
|
#INCLUDE= -I$(subst ;, -I, $(SRCPATH))
|
|
INCLUDE= -I. -I../../Include
|
|
|
|
# Path to search for .c files
|
|
vpath %.c .;..;$(SRCPATH)
|
|
|
|
# Top of the package tree
|
|
TOP= ../../
|
|
|
|
# Directory for output files
|
|
OUTBASE= out/
|
|
OUT= $(OUTBASE)$(MODE)/
|
|
|
|
# Additional libraries
|
|
LIBS= -lsocket
|
|
|
|
# Utility macro: replacement for $^
|
|
^^= $(filter-out %$A,$^)
|
|
# Use $(L^) to link with all libraries specified as dependencies
|
|
L^= $(addprefix -l,$(basename $(notdir $(filter %$A,$+))))
|
|
|
|
# Build rules
|
|
$(OUT)%$O: %.c
|
|
$(CC) $(CFLAGS.LIB) -c $< -o $@
|
|
|
|
%.a:
|
|
$(LD) $(LDFLAGS.A) -o $@ $(^^) $(L^)
|
|
|
|
%.dll:
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
%.pyd: $(OUT)%module$O $(OUT)%_m.def
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(PYTHON.IMPLIB) $(LIBS)
|
|
|
|
%.exe:
|
|
$(LD) $(LDFLAGS.EXE) -o $@ $(^^) $(L^)
|
|
|
|
%_m.def:
|
|
@echo Creating .DEF file: $@
|
|
@echo LIBRARY $(notdir $*) INITINSTANCE TERMINSTANCE >$@
|
|
ifeq ($(DESCRIPTION.$(notdir $*)$(MODULE.EXT)),)
|
|
@echo DESCRIPTION $(DQUOTE)Python standard module $(notdir $*)$(DQUOTE) >>$@
|
|
else
|
|
@echo DESCRIPTION $(DQUOTE)$(DESCRIPTION.$(notdir $*)$(MODULE.EXT))$(DQUOTE) >>$@
|
|
endif
|
|
@echo DATA MULTIPLE NONSHARED >>$@
|
|
@echo EXPORTS >>$@
|
|
@echo init$(notdir $*) >>$@
|
|
|
|
%.def:
|
|
@echo Creating .DEF file: $@
|
|
@echo NAME $(notdir $*) $(EXETYPE.$(notdir $*).exe) >$@
|
|
@echo DESCRIPTION $(DQUOTE)$(DESCRIPTION.$(notdir $*).exe)$(DQUOTE) >>$@
|
|
@echo STACKSIZE 1048576 >>$@
|
|
|
|
# Output file names
|
|
PYTHON_VER= 2.3
|
|
PYTHON_LIB= python23
|
|
PYTHON.LIB= $(PYTHON_LIB)_s$A
|
|
PYTHON.IMPLIB= $(PYTHON_LIB)$A
|
|
ifeq ($(EXEOMF),yes)
|
|
PYTHON.EXEIMP= $(PYTHON.IMPLIB)
|
|
LDMODE.EXE= -Zomf
|
|
else
|
|
PYTHON.EXEIMP= $(PYTHON_LIB).a
|
|
LDMODE.EXE =
|
|
endif
|
|
PYTHON.DLL= $(PYTHON_LIB).dll
|
|
PYTHON.DEF= $(PYTHON_LIB).def
|
|
PYTHON.EXE= python.exe
|
|
PYTHONPM.EXE= pythonpm.exe
|
|
PGEN.EXE= pgen.exe
|
|
LIBRARY= $(PYTHON.LIB)
|
|
LD_LIBRARY= $(PYTHON.IMPLIB)
|
|
|
|
# Additional executable parameters
|
|
EXETYPE.$(PYTHON.EXE)= WINDOWCOMPAT
|
|
EXETYPE.$(PYTHONPM.EXE)= WINDOWAPI
|
|
EXETYPE.$(PGEN.EXE)= WINDOWCOMPAT
|
|
DESCRIPTION.$(PYTHON.EXE)= Python object-oriented programming language interpreter for OS/2
|
|
DESCRIPTION.$(PYTHONPM.EXE)= $(DESCRIPTION.$(PYTHON.EXE))
|
|
DESCRIPTION.$(PGEN.EXE)= Python object-oriented programming language parser generator for OS/2
|
|
|
|
# Module descriptions
|
|
DESCRIPTION.zlib$(MODULE.EXT)= Python Extension DLL for accessing the InfoZip compression library
|
|
DESCRIPTION.crypt$(MODULE.EXT)= Python Extension DLL implementing the crypt$(BRO)$(BRC) function
|
|
DESCRIPTION._tkinter$(MODULE.EXT)= Python Extension DLL for access to Tcl/Tk Environment
|
|
DESCRIPTION.mpz$(MODULE.EXT)= Python Extension DLL for access to GNU multi-precision library
|
|
DESCRIPTION.readline$(MODULE.EXT)= Python Extension DLL for access to GNU ReadLine library
|
|
DESCRIPTION.bsddb185$(MODULE.EXT)= Python Extension DLL for access to BSD DB (v1.85) library
|
|
DESCRIPTION._curses$(MODULE.EXT)= Python Extension DLL for access to ncurses library
|
|
DESCRIPTION.pyexpat$(MODULE.EXT)= Python Extension DLL for access to expat library
|
|
DESCRIPTION.bz2$(MODULE.EXT)= Python Extension DLL for accessing the bz2 compression library
|
|
|
|
# Source files
|
|
SRC.OS2EMX= config.c dlfcn.c getpathp.c
|
|
SRC.MAIN= $(addprefix $(TOP), \
|
|
Modules/getbuildinfo.c \
|
|
Modules/main.c)
|
|
SRC.MODULES= $(addprefix $(TOP), \
|
|
Modules/gcmodule.c \
|
|
Modules/signalmodule.c \
|
|
Modules/posixmodule.c \
|
|
Modules/threadmodule.c)
|
|
SRC.PARSE1= $(addprefix $(TOP), \
|
|
Parser/acceler.c \
|
|
Parser/grammar1.c \
|
|
Parser/listnode.c \
|
|
Parser/node.c \
|
|
Parser/parser.c \
|
|
Parser/parsetok.c \
|
|
Parser/bitset.c \
|
|
Parser/metagrammar.c)
|
|
SRC.PARSE2= $(addprefix $(TOP), \
|
|
Parser/tokenizer.c \
|
|
Parser/myreadline.c)
|
|
SRC.PARSER= $(SRC.PARSE1) \
|
|
$(SRC.PARSE2)
|
|
SRC.PYTHON= $(addprefix $(TOP), \
|
|
Python/bltinmodule.c \
|
|
Python/exceptions.c \
|
|
Python/ceval.c \
|
|
Python/compile.c \
|
|
Python/codecs.c \
|
|
Python/errors.c \
|
|
Python/frozen.c \
|
|
Python/frozenmain.c \
|
|
Python/future.c \
|
|
Python/getargs.c \
|
|
Python/getcompiler.c \
|
|
Python/getcopyright.c \
|
|
Python/getmtime.c \
|
|
Python/getplatform.c \
|
|
Python/getversion.c \
|
|
Python/graminit.c \
|
|
Python/import.c \
|
|
Python/importdl.c \
|
|
Python/marshal.c \
|
|
Python/modsupport.c \
|
|
Python/mysnprintf.c \
|
|
Python/mystrtoul.c \
|
|
Python/pyfpe.c \
|
|
Python/pystate.c \
|
|
Python/pythonrun.c \
|
|
Python/structmember.c \
|
|
Python/symtable.c \
|
|
Python/sysmodule.c \
|
|
Python/traceback.c \
|
|
Python/getopt.c \
|
|
Python/dynload_shlib.c \
|
|
Python/thread.c)
|
|
SRC.OBJECT= $(addprefix $(TOP), \
|
|
Objects/abstract.c \
|
|
Objects/boolobject.c \
|
|
Objects/bufferobject.c \
|
|
Objects/cellobject.c \
|
|
Objects/classobject.c \
|
|
Objects/cobject.c \
|
|
Objects/complexobject.c \
|
|
Objects/descrobject.c \
|
|
Objects/dictobject.c \
|
|
Objects/enumobject.c \
|
|
Objects/fileobject.c \
|
|
Objects/floatobject.c \
|
|
Objects/frameobject.c \
|
|
Objects/funcobject.c \
|
|
Objects/intobject.c \
|
|
Objects/iterobject.c \
|
|
Objects/listobject.c \
|
|
Objects/longobject.c \
|
|
Objects/methodobject.c \
|
|
Objects/moduleobject.c \
|
|
Objects/object.c \
|
|
Objects/obmalloc.c \
|
|
Objects/rangeobject.c \
|
|
Objects/sliceobject.c \
|
|
Objects/stringobject.c \
|
|
Objects/structseq.c \
|
|
Objects/tupleobject.c \
|
|
Objects/typeobject.c \
|
|
Objects/unicodeobject.c \
|
|
Objects/unicodectype.c \
|
|
Objects/weakrefobject.c)
|
|
|
|
SRC.LIB= $(SRC.OS2EMX) \
|
|
$(SRC.MAIN) \
|
|
$(SRC.PARSER) \
|
|
$(SRC.OBJECT) \
|
|
$(SRC.PYTHON) \
|
|
$(SRC.MODULES)
|
|
OBJ.LIB= $(addprefix $(OUT),$(notdir $(SRC.LIB:.c=$O)))
|
|
|
|
SRC.PGEN= $(SRC.PARSE1) \
|
|
$(addprefix $(TOP), \
|
|
Objects/obmalloc.c) \
|
|
$(addprefix $(TOP), \
|
|
Python/mysnprintf.c) \
|
|
$(addprefix $(TOP), \
|
|
Parser/tokenizer_pgen.c \
|
|
Parser/pgenmain.c \
|
|
Parser/pgen.c \
|
|
Parser/printgrammar.c \
|
|
Parser/grammar.c \
|
|
Parser/firstsets.c) \
|
|
|
|
OBJ.PGEN= $(addprefix $(OUT),$(notdir $(SRC.PGEN:.c=$O)))
|
|
|
|
SRC.EXE= $(TOP)Modules/python.c
|
|
SRC.PMEXE= pythonpm.c
|
|
|
|
# Python modules to be dynamically loaded that:
|
|
# 1) have only single source file and require no extra libs
|
|
# 2) use the standard module naming convention
|
|
# (the 'module' in ?????module.c is assumed)
|
|
# - these can be built with implicit rules
|
|
EASYEXTMODULES= array \
|
|
cmath \
|
|
_codecs \
|
|
datetime \
|
|
dl \
|
|
errno \
|
|
fcntl \
|
|
fpectl \
|
|
fpetest \
|
|
_locale \
|
|
math \
|
|
parser \
|
|
pwd \
|
|
_random \
|
|
rgbimg \
|
|
rotor \
|
|
select \
|
|
sha \
|
|
strop \
|
|
struct \
|
|
time \
|
|
timing
|
|
|
|
# Python modules to be dynamically loaded that need explicit build rules
|
|
# (either multiple source files and/or non-standard module naming)
|
|
# (NOTE: use shortened names for modules affected by 8 char name limit)
|
|
HARDEXTMODULES= binascii \
|
|
cPickle \
|
|
cStringI \
|
|
_hotshot \
|
|
imageop \
|
|
md5 \
|
|
operator \
|
|
pcre \
|
|
regex \
|
|
_socket \
|
|
_sre \
|
|
_symtabl \
|
|
termios \
|
|
_testcap \
|
|
unicoded \
|
|
_weakref \
|
|
xreadlin \
|
|
xxsubtyp \
|
|
zipimpor
|
|
|
|
# Python external ($(MODULE.EXT)) modules - can be EASY or HARD
|
|
ifeq ($(ZLIB),yes)
|
|
HARDEXTMODULES+= zlib
|
|
endif
|
|
ifeq ($(UFC),yes)
|
|
HARDEXTMODULES+= crypt
|
|
endif
|
|
ifeq ($(TCLTK),yes)
|
|
HARDEXTMODULES+= _tkinter
|
|
CFLAGS+= -DHAS_DIRENT -I/TclTk80/include
|
|
TK_LIBS+= -L/TclTk80/lib -ltcl80 -ltk80
|
|
endif
|
|
ifeq ($(GMPZ),yes)
|
|
HARDEXTMODULES+= mpz
|
|
endif
|
|
ifeq ($(GREADLINE),yes)
|
|
HARDEXTMODULES+= readline
|
|
endif
|
|
ifeq ($(BSDDB),yes)
|
|
HARDEXTMODULES+= bsddb185
|
|
endif
|
|
ifeq ($(CURSES),yes)
|
|
HARDEXTMODULES+= _curses _curses_
|
|
endif
|
|
ifeq ($(GDBM),yes)
|
|
HARDEXTMODULES+= gdbm dbm
|
|
endif
|
|
ifeq ($(BZ2),yes)
|
|
HARDEXTMODULES+= bz2
|
|
endif
|
|
|
|
# Expat is now distributed with the Python source
|
|
HARDEXTMODULES+= pyexpat
|
|
EXPAT.INC= -I../../Modules/expat
|
|
EXPAT.DEF= -DHAVE_EXPAT_H -DXML_NS=1 -DXML_DTD=1 -DXML_BYTE_ORDER=12 \
|
|
-DXML_CONTENT_BYTES=1024
|
|
EXPAT.SRC= $(addprefix ../../Modules/expat/, \
|
|
xmlparse.c \
|
|
xmlrole.c \
|
|
xmltok.c)
|
|
|
|
# all the external modules
|
|
EXTERNDLLS= $(addsuffix $(MODULE.EXT),$(patsubst %module,%,$(EASYEXTMODULES)))
|
|
EXTERNDLLS+= $(addsuffix $(MODULE.EXT),$(patsubst %module,%,$(HARDEXTMODULES)))
|
|
|
|
# Targets
|
|
all: $(OUT) $(PYTHON.LIB) $(PYTHON.DEF) $(PYTHON.IMPLIB) $(PYTHON.DLL) \
|
|
$(PYTHON.EXE) $(PYTHONPM.EXE) $(PGEN.EXE) $(EXTERNDLLS)
|
|
|
|
clean:
|
|
rm -f $(OUT)*
|
|
rm -f $(PYTHON.LIB) $(PYTHON.IMPLIB) $(PYTHON.EXEIMP) $(PYTHON.DLL) \
|
|
$(PYTHON.EXE) $(PYTHONPM.EXE) $(PGEN.EXE) *$(MODULE.EXT)
|
|
|
|
lx:
|
|
@echo Packing everything with lxLite...
|
|
lxlite $(PYTHON.DLL) $(PYTHON.EXE) $(PYTHONPM.EXE) $(PGEN.EXE)
|
|
|
|
depend: $(OUTBASE)
|
|
makedep -f $(OUTBASE)python.dep -o $(BUCK)O -p $(BUCK)\(OUT\) \
|
|
-r -c $(INCLUDE) $(SRC.LIB) $(SRC.PGEN)
|
|
|
|
$(OUT): $(OUTBASE)
|
|
|
|
$(OUT) $(OUTBASE):
|
|
mkdir.exe $@
|
|
|
|
$(PYTHON.LIB): $(OBJ.LIB)
|
|
rm.exe -f $@
|
|
$(AR) $(ARFLAGS) $@ $^
|
|
|
|
$(PYTHON.DEF): $(PYTHON.LIB)
|
|
@echo Creating .DEF file: $@
|
|
@echo LIBRARY $(PYTHON_LIB) INITINSTANCE TERMINSTANCE >$@
|
|
@echo DESCRIPTION $(DQUOTE)Python $(PYTHON_VER) Core DLL$(DQUOTE) >>$@
|
|
@echo PROTMODE >>$@
|
|
@echo DATA MULTIPLE NONSHARED >>$@
|
|
@echo EXPORTS >>$@
|
|
$(EXPLIB) -u $(PYTHON.LIB) >>$@
|
|
|
|
$(PYTHON.IMPLIB): $(PYTHON.DEF)
|
|
$(IMPLIB) -o $@ $^
|
|
|
|
$(PYTHON.EXEIMP): $(PYTHON.DEF)
|
|
$(IMPLIB) -o $@ $^
|
|
|
|
$(PYTHON.DLL): $(OUT)dllentry$O $(PYTHON.LIB) $(PYTHON.DEF)
|
|
|
|
# Explicit make targets for the .EXEs to be able to use LD to link
|
|
# (so that fork() will work if required)
|
|
|
|
$(PYTHON.EXE): $(SRC.EXE) $(PYTHON.EXEIMP) $(OUT)python.def
|
|
$(CC) -Zmt $(LDMODE.EXE) -Zcrtdll -Wall $(INCLUDE) -L. -lgcc -o $@ $(SRC.EXE) $(PYTHON.EXEIMP) $(LIBS) $(OUT)python.def
|
|
$(EXEOPT) -aq $(PYTHON.EXE) -h$(NFILES)
|
|
|
|
$(PYTHONPM.EXE): $(SRC.PMEXE) $(PYTHON.EXEIMP) $(OUT)pythonpm.def
|
|
$(CC) -Zmt $(LDMODE.EXE) -Zcrtdll -Wall $(INCLUDE) -L. -lgcc -o $@ $(SRC.PMEXE) $(PYTHON.EXEIMP) $(LIBS) $(OUT)pythonpm.def
|
|
$(EXEOPT) -aq $(PYTHONPM.EXE) -h$(NFILES)
|
|
|
|
$(PGEN.EXE): $(OBJ.PGEN) $(OUT)pgen.def
|
|
|
|
# Explicit building instructions for those external modules that require
|
|
# awkward handling (due e.g. to non-std naming, or multiple source files)
|
|
# - standard modules
|
|
binascii$(MODULE.EXT): $(OUT)binascii$O $(OUT)binascii_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
cPickle$(MODULE.EXT): $(OUT)cPickle$O $(OUT)cPickle_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
# cStringIO needs to be renamed to be useful (8 char DLL name limit)
|
|
cStringIO$(MODULE.EXT): $(OUT)cStringIO$O $(OUT)cStringIO_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
cStringI$(MODULE.EXT): cStringIO$(MODULE.EXT)
|
|
cp $^ $@
|
|
|
|
_hotshot$(MODULE.EXT): $(OUT)_hotshot$O $(OUT)_hotshot_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
imageop$(MODULE.EXT): $(OUT)imageop$O $(OUT)imageop_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
md5$(MODULE.EXT): $(OUT)md5module$O $(OUT)md5c$O $(OUT)md5_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
operator$(MODULE.EXT): $(OUT)operator$O $(OUT)operator_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
pcre$(MODULE.EXT): $(OUT)pcremodule$O $(OUT)pypcre$O $(OUT)pcre_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
regex$(MODULE.EXT): $(OUT)regexmodule$O $(OUT)regexpr$O $(OUT)regex_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
_socket$(MODULE.EXT): $(OUT)socketmodule$O $(OUT)_socket_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
_sre$(MODULE.EXT): $(OUT)_sre$O $(OUT)_sre_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
# _symtable needs to be renamed to be useful
|
|
_symtable$(MODULE.EXT): $(OUT)symtablemodule$O $(OUT)_symtable_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
_symtabl$(MODULE.EXT): _symtable$(MODULE.EXT)
|
|
cp $^ $@
|
|
|
|
termios$(MODULE.EXT): $(OUT)termios$O $(OUT)termios_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
# _testcapi needs to be renamed to be useful
|
|
_testcapi$(MODULE.EXT): $(OUT)_testcapimodule$O $(OUT)_testcapi_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
_testcap$(MODULE.EXT): _testcapi$(MODULE.EXT)
|
|
cp $^ $@
|
|
|
|
# unicodedata needs to be renamed to be useful
|
|
unicodedata$(MODULE.EXT): $(OUT)unicodedata$O $(OUT)unicodedata_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) $(MODULE_LIBS)
|
|
|
|
unicoded$(MODULE.EXT): unicodedata$(MODULE.EXT)
|
|
cp $^ $@
|
|
|
|
_weakref$(MODULE.EXT): $(OUT)_weakref$O $(OUT)_weakref_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
# xreadlines needs to be renamed to be useful
|
|
xreadlines$(MODULE.EXT): $(OUT)xreadlinesmodule$O $(OUT)xreadlines_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
xreadlin$(MODULE.EXT): xreadlines$(MODULE.EXT)
|
|
cp $^ $@
|
|
|
|
# xxsubtype needs to be renamed to be useful
|
|
xxsubtype$(MODULE.EXT): $(OUT)xxsubtype$O $(OUT)xxsubtype_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
xxsubtyp$(MODULE.EXT): xxsubtype$(MODULE.EXT)
|
|
cp $^ $@
|
|
|
|
# zipimport needs to be renamed to be useful
|
|
zipimport$(MODULE.EXT): $(OUT)zipimport$O $(OUT)zipimport_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
zipimpor$(MODULE.EXT): zipimport$(MODULE.EXT)
|
|
cp $^ $@
|
|
|
|
# - optional modules (requiring other software to be installed)
|
|
bsddb185$(MODULE.EXT): $(OUT)bsddbmodule$O $(OUT)bsddb185_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) -ldb $(LIBS)
|
|
|
|
crypt$(MODULE.EXT): $(OUT)cryptmodule$O $(OUT)crypt_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) -lufc $(LIBS)
|
|
|
|
# The _curses_panel module requires a couple of ncurses library entry
|
|
# points, which are best exposed as exports from the _curses module DLL
|
|
$(OUT)_curses_m.def:
|
|
@echo Creating .DEF file: $@
|
|
@echo LIBRARY $(notdir $*) INITINSTANCE TERMINSTANCE >$@
|
|
@echo DESCRIPTION $(DQUOTE)$(DESCRIPTION.$(notdir $*)$(MODULE.EXT))$(DQUOTE) >>$@
|
|
@echo DATA MULTIPLE NONSHARED >>$@
|
|
@echo EXPORTS >>$@
|
|
@echo init_curses >>$@
|
|
@echo wnoutrefresh >>$@
|
|
@echo _nc_panelhook >>$@
|
|
@echo is_linetouched >>$@
|
|
@echo mvwin >>$@
|
|
@echo stdscr >>$@
|
|
@echo wtouchln >>$@
|
|
|
|
$(OUT)_curses_panel_m.def:
|
|
@echo Creating .DEF file: $@
|
|
@echo LIBRARY $(notdir $*) INITINSTANCE TERMINSTANCE >$@
|
|
@echo DESCRIPTION $(DQUOTE)Python standard module $(notdir $*)$(DQUOTE) >>$@
|
|
@echo DATA MULTIPLE NONSHARED >>$@
|
|
@echo IMPORTS >>$@
|
|
@echo _curses.wnoutrefresh >>$@
|
|
@echo _curses._nc_panelhook >>$@
|
|
@echo _curses.is_linetouched >>$@
|
|
@echo _curses.mvwin >>$@
|
|
@echo _curses.stdscr >>$@
|
|
@echo _curses.wtouchln >>$@
|
|
@echo EXPORTS >>$@
|
|
@echo init_curses_panel >>$@
|
|
|
|
_curses$(MODULE.EXT): $(OUT)_cursesmodule$O $(OUT)_curses_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) -lncurses
|
|
|
|
# curses_panel needs to be renamed to be useful
|
|
_curses_panel$(MODULE.EXT): $(OUT)_curses_panel$O $(OUT)_curses_panel_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) -lpanel
|
|
|
|
_curses_$(MODULE.EXT): _curses_panel$(MODULE.EXT)
|
|
cp $^ $@
|
|
|
|
dbm$(MODULE.EXT): $(OUT)dbmmodule$O $(OUT)dbm_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) -lgdbm
|
|
|
|
gdbm$(MODULE.EXT): $(OUT)gdbmmodule$O $(OUT)gdbm_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) -lgdbm
|
|
|
|
mpz$(MODULE.EXT): $(OUT)mpzmodule$O $(OUT)mpz_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) -lgmp
|
|
|
|
# Expat is now distributed with Python, so use the included version
|
|
$(OUT)pyexpat$O: ../../Modules/pyexpat.c
|
|
$(CC) $(CFLAGS) $(EXPAT.INC) -c -o $@ $^
|
|
$(OUT)xmlparse$O: ../../Modules/expat/xmlparse.c
|
|
$(CC) $(CFLAGS) $(EXPAT.INC) $(EXPAT.DEF) -c -o $@ $^
|
|
$(OUT)xmlrole$O: ../../Modules/expat/xmlrole.c
|
|
$(CC) $(CFLAGS) $(EXPAT.INC) $(EXPAT.DEF) -c -o $@ $^
|
|
$(OUT)xmltok$O: ../../Modules/expat/xmltok.c
|
|
$(CC) $(CFLAGS) $(EXPAT.INC) $(EXPAT.DEF) -c -o $@ $^
|
|
pyexpat$(MODULE.EXT): $(OUT)pyexpat$O $(OUT)xmlparse$O $(OUT)xmlrole$O \
|
|
$(OUT)xmltok$O $(OUT)pyexpat_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS)
|
|
|
|
readline$(MODULE.EXT): $(OUT)readline$O $(OUT)readline_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) -lreadline -lncurses
|
|
|
|
#_tkinter$(MODULE.EXT): $(OUT)_tkinter$O $(OUT)tclNotify$O $(OUT)tkappinit$O
|
|
_tkinter$(MODULE.EXT): $(OUT)_tkinter$O $(OUT)tclNotify$O \
|
|
$(OUT)_tkinter_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) $(TK_LIBS)
|
|
|
|
zlib$(MODULE.EXT): $(OUT)zlibmodule$O $(OUT)zlib_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) -lz
|
|
|
|
bz2$(MODULE.EXT): $(OUT)bz2module$O $(OUT)bz2_m.def $(PYTHON.IMPLIB)
|
|
$(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) -lbz2
|
|
|
|
# the test target
|
|
test:
|
|
-find ../../Lib -name "*.py[co]" -exec rm {} ";"
|
|
-./python -E -tt ../../lib/test/regrtest.py -l -u "network"
|
|
./python -E -tt ../../lib/test/regrtest.py -l -u "network"
|
|
|
|
-include $(OUTBASE)python.dep
|