# File: python.mms
#
# 30-Apr-2002	J. Malmberg	Port to OpenVMS
#===========================================================================
#prefix=@prefix@
#exec_prefix=@exec_prefix@
#bindir=@bindir@
#mandir=@mandir@

#LIBS=@LIBS@
#CC=@CC@
PYINC=PRJ_INCLUDE:,PRJ_PARSER:,PRJ_PYTHON:,PRJ_MODULES:
CINC=/include=(PRJ_SRC:,$(PYINC),FRONTPORT__DIR:)
CDEFX= MOD_'f$element(0,"-",f$parse("$*",,,"NAME"))', HAVE_CONFIG_H
CDEF = /define=($(CDEFX))
CDEF1 = /define=($(CDEFX),BUILDNO='f$parse("lcl_src:buildno.tmp",,,"VERSION")')
CWARN= /STANDARD=PORTABLE/WARN=ENABLE=(LEVEL4,QUESTCODE)
CSTD= /STANDARD=PORTABLE/ACCEPT=NOVAXC_KEYWORDS
CFLAGS=/PREFIX=ALL $(CSTD)$(CWARN)$(CINC)$(CDEF)/NESTED_INCLUDE_DIR=NONE
CFLAGS1=/PREFIX=ALL $(CSTD)$(CWARN)$(CINC)$(CDEF1)/NESTED_INCLUDE_DIR=NONE

EVE = EDIT/TPU/SECTION=EVE$SECTION/NODISPLAY

RUNOFF = RUNOFF
RNOFLAGS = /NOBOLD/SIMULATE	#Most harmless defaults for dumb video term.
RNHFLAGS = /NOBOLD/NOSIMULATE

UNIX_2_VMS = /COMMAND=prj_src:unix_c_to_vms_c.tpu

TROFF_2_DSR = /COMMAND=prj_src:unix_troff_to_dsr.tpu



.SUFFIXES
.SUFFIXES : .exe .olb .obj .gdiff .c .h .mem .rno .hlb .hlp .rnh


.C.OBJ :
	$(CC)$(CFLAGS)/object=$(MMS$TARGET) $(MMS$SOURCE)

#	$define/user readline frontport__dir:


.OBJ.OLB :
	$if f$search("$(MMS$TARGET)") .eqs. "" then \
	  library/create/object $(MMS$TARGET)
	$library/replace $(MMS$TARGET) $(MMS$SOURCE)

.HLP.HLB :
	$if f$search("$(MMS$TARGET)") .eqs. "" then \
	  library/create/help $(MMS$TARGET)
	$library/replace $(MMS$TARGET) $(MMS$SOURCE)

.RNO.MEM :
	$(RUNOFF)$(RNOFLAGS)/OUTPUT=$(MMS$TARGET) $(MMS$SOURCE)

.RNH.HLP :
	$(RUNOFF)$(RNHFLAGS)/OUTPUT=$(MMS$TARGET) $(MMS$SOURCE)

.h.gdiff :
    @ $define/user sys$output $(MMS$TARGET)
    $gdiff -u 'f$element(1,",","$(MMS$SOURCE_LIST)")' $(mms$source)

.c.gdiff :
    @ $define/user sys$output $(MMS$TARGET)
    $gdiff -u 'f$element(1,",","$(MMS$SOURCE_LIST)")' $(mms$source)


############################################################################
# Header files

PYCONFIG_H = lcl_src:pyconfig.h, lcl_src:pyconfig_vms.h

INCLUDE_GRAMMAR_H = prj_include:grammar.h prj_include:bitset.h

OBJIMPL_H = prj_include:objimpl.h $(PYMEM_H)

PGENHEADERS_H = prj_include:pgenheaders.h $(PYCONFIG_H) \
		prj_include:pymem.h prj_include:pydebug.h

PYMEM_H = prj_include:pymem.h $(PYPORT_H)

PYPORT_H = prj_include:pyport.h $(PYCONFIG_H)

PYTHON_H = prj_include:python.h, prj_include:patchlevel.h, $(PYCONFIG_H), \
	$(PYPORT_H) $(PYMEM_H) prj_include:object.h $(OBJIMPL_H) \
	prj_include:pydebug.h prj_include:unicodeobject.h \
	prj_include:intobject.h prj_include:longobject.h \
	prj_include:floatobject.h prj_include:complexobject.h \
	prj_include:rangeobject.h prj_include:stringobject.h \
	prj_include:bufferobject.h prj_include:tupleobject.h \
	prj_include:listobject.h prj_include:dictobject.h \
	prj_include:methodobject.h prj_include:moduleobject.h \
	prj_include:funcobject.h prj_include:classobject.h \
	prj_include:fileobject.h prj_include:cobject.h \
	prj_include:traceback.h prj_include:sliceobject.h \
	prj_include:cellobject.h prj_include:iterobject.h \
	prj_include:descrobject.h prj_include:weakrefobject.h \
	prj_include:codecs.h prj_include:pyerrors.h \
	prj_include:pystate.h prj_include:modsupport.h \
	prj_include:pythonrun.h prj_include:ceval.h \
	prj_include:sysmodule.h prj_include:intrcheck.h \
	prj_include:import.h prj_include:abstract.h \
	prj_include:pyfpe.h

PCRE_INT_H = prj_modules:pcre-int.h $(PCRE_H)

PCRE_H = prj_modules:pcre.h $(PYTHON_H)

SRE_H = prj_modules:sre.h prj_modules:sre_constants.h

TOKENIZER_H = prj_parser:tokenizer.h prj_include:token.h



PYTHON_HEADERS= \
		$(PYTHON_H) \
		Prj_include:abstract.h \
		Prj_include:bufferobject.h \
		Prj_include:ceval.h \
		Prj_include:classobject.h \
		Prj_include:cobject.h \
		Prj_include:codecs.h \
		Prj_include:compile.h \
		Prj_include:complexobject.h \
		Prj_include:descrobject.h \
		Prj_include:dictobject.h \
		Prj_include:fileobject.h \
		Prj_include:floatobject.h \
		Prj_include:funcobject.h \
		Prj_include:import.h \
		Prj_include:intobject.h \
		Prj_include:intrcheck.h \
		Prj_include:iterobject.h \
		Prj_include:listobject.h \
		Prj_include:longobject.h \
		Prj_include:methodobject.h \
		Prj_include:modsupport.h \
		Prj_include:moduleobject.h \
		Prj_include:object.h \
		$(OBJIMPL_H) \
		Prj_include:patchlevel.h \
		Prj_include:pydebug.h \
		Prj_include:pyerrors.h \
		Prj_include:pyfpe.h \
		$(PYMEM_H) \
		$(PYPORT_H) \
		Prj_include:pystate.h \
		Prj_include:pythonrun.h \
		Prj_include:rangeobject.h \
		Prj_include:sliceobject.h \
		Prj_include:stringobject.h \
		Prj_include:structseq.h \
		Prj_include:structmember.h \
		Prj_include:symtable.h \
		Prj_include:sysmodule.h \
		Prj_include:traceback.h \
		Prj_include:tupleobject.h \
		Prj_include:unicodeobject.h \
		Prj_include:weakrefobject.h \
		$(PYCONFIG_H)

#$(LIBRARY_OBJS) $(MODOBJS) lcl_modules:$(MAINOBJ) : $(PYTHON_HEADERS)


#all : start rsync tls man gdiff
#	@ $show time
#	@ $write sys$output "All targets are up to date."
#
#
#man : lcl_src:rsync.mem lcl_src:rsyncd_conf.mem \
#      lcl_src:rsync.hlp lcl_src:rsyncd_conf.hlp lcl_src:rsync.hlb
#	@ $show time
#	@ $write sys$output "Documentation formatted and Help library built."

exe = .exe
ARCH = AXP
LIBRARY=	lcl_src:libpython.olb
LDLIBRARY=      lcl_src:libpython.exe
#BLDLIBRARY=     @BLDLIBRARY@
#DLLLIBRARY=	@DLLLIBRARY@
#LDLIBRARYDIR=   @LDLIBRARYDIR@

MAINOBJ=	python.obj
BUILDPYTHON=	buildpython

DYNLOADFILE = dynload_shlib.obj

#########################################################################
# Rules

# Default target
#all :		LCL_SRC:$(BUILDPYTHON).EXE oldsharedmods sharedmods
all :	start	LCL_SRC:$(BUILDPYTHON).EXE sharedmods
    @ $write sys$output "Python build claims to be complete"


.INCLUDE PRJ_SRC:PYTHON_VMS_MODULES.MMS

##########################################################################
# Modules
MODULE_OBJS =	\
		lcl_modules:config.obj \
		lcl_modules:getpath.obj \
		lcl_modules:main.obj \
		lcl_modules:gcmodule.obj \	#below are variable
		$(VMS_MODULES)

#		lcl_modules:vms_getpath.obj \
#

# Used of signalmodule.obj is not available
SIGNAL_OBJS=	lcl_parser:intrcheck.obj \
		lcl_python:sigcheck.obj


##########################################################################
# Grammar
GRAMMAR_H=	lcl_include:graminit.h
GRAMMAR_C=	lcl_python:graminit.c
GRAMMAR_INPUT=	prj_grammar:Grammar.

##########################################################################
# Parser
PGEN=		lcl_parser:pgen$(EXE)

POBJS=		\
		lcl_parser:acceler.obj \
		lcl_parser:grammar1.obj \
		lcl_parser:listnode.obj \
		lcl_parser:node.obj \
		lcl_parser:parser.obj \
		lcl_parser:parsetok.obj \
		lcl_parser:bitset.obj \
		lcl_parser:metagrammar.obj

#PARSER_OBJS=	$(POBJS) lcl_parser:myreadline.obj
PARSER_OBJS=	lcl_parser:myreadline.obj

#		lcl_parser:tokenizer.obj

PGOBJS=		\
		lcl_objects:obmalloc.obj \
		lcl_python:mysnprintf.obj \
		lcl_parser:tokenizer_pgen.obj \
		lcl_parser:firstsets.obj \
		lcl_parser:grammar.obj \
		lcl_parser:pgen.obj \
		lcl_parser:printgrammar.obj \
		lcl_parser:pgenmain.obj

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


##########################################################################
# Python
PYTHON_OBJS=	\
		lcl_python:bltinmodule.obj \
		lcl_python:exceptions.obj \
		lcl_python:ceval.obj \
		lcl_python:compile.obj \
		lcl_python:codecs.obj \
		lcl_python:errors.obj \
		lcl_python:frozen.obj \
		lcl_python:frozenmain.obj \
		lcl_python:future.obj \
		lcl_python:getargs.obj \
		lcl_python:getcompiler.obj \
		lcl_python:getcopyright.obj \
		lcl_python:getmtime.obj \
		lcl_python:getplatform.obj \
		lcl_python:getversion.obj \
		lcl_python:graminit.obj \
		lcl_python:import.obj \
		lcl_python:importdl.obj \
		lcl_python:marshal.obj \
		lcl_python:modsupport.obj \
		lcl_python:mystrtoul.obj \
		lcl_python:mysnprintf.obj \
		lcl_python:pyfpe.obj \
		lcl_python:pystate.obj \
		lcl_python:pythonrun.obj \
		lcl_python:structmember.obj \
		lcl_python:symtable.obj \
		lcl_python:sysmodule.obj \
		lcl_python:traceback.obj \
		lcl_python:getopt.obj \
		lcl_python:$(DYNLOADFILE) \
		$(MACHDEP_OBJS) \
		$(THREADOBJS)


##########################################################################
# Objects
OBJECT_OBJS=	\
		Lcl_objects:abstract.obj \
		lcl_objects:boolobject.obj \
		Lcl_objects:bufferobject.obj \
		Lcl_objects:cellobject.obj \
		Lcl_objects:classobject.obj \
		Lcl_objects:cobject.obj \
		Lcl_objects:complexobject.obj \
		Lcl_objects:descrobject.obj \
		lcl_objects:enumobject.obj \
		Lcl_objects:fileobject.obj \
		Lcl_objects:floatobject.obj \
		Lcl_objects:frameobject.obj \
		Lcl_objects:funcobject.obj \
		Lcl_objects:intobject.obj \
		Lcl_objects:iterobject.obj \
		Lcl_objects:listobject.obj \
		Lcl_objects:longobject.obj \
		Lcl_objects:dictobject.obj \
		Lcl_objects:methodobject.obj \
		Lcl_objects:moduleobject.obj \
		Lcl_objects:object.obj \
		Lcl_objects:rangeobject.obj \
		Lcl_objects:sliceobject.obj \
		Lcl_objects:stringobject.obj \
		Lcl_objects:structseq.obj \
		Lcl_objects:tupleobject.obj \
		Lcl_objects:typeobject.obj \
		Lcl_objects:weakrefobject.obj \
		$(UNICODE_OBJS)


##########################################################################
# objects that get linked into the Python library
LIBRARY_OBJS=	\
		Prj_modules:getbuildinfo.obj \
		$(PARSER_OBJS) \
		$(OBJECT_OBJS) \
		$(PYTHON_OBJS) \
		$(MODULE_OBJS) \
		$(SIGNAL_OBJS)

#		$(MODOBJS)

start :
	@ $write sys$output "Starting build"
	@ $show time

gdiff :
	@ $show time
	@ $write sys$output "Gdiff patches are built."


# Build the interpreter
LCL_SRC:$(BUILDPYTHON).EXE : lcl_modules:$(MAINOBJ) $(LDLIBRARY) \
		lcl_src:python.opt, lcl_src:py_ident.opt
	@ $write sys$output "build the interpreter"
	$ define/user libpython lcl_src:libpython.exe
	link/exe=$@ lcl_modules:$(MAINOBJ),PRJ_SRC:PYTHON.OPT/OPTION,\
		lcl_src:py_ident.opt/opt


#		$(LINKCC) $(LDFLAGS) $(LINKFORSHARED) -o $@ \
#			lcl_modules:$(MAINOBJ) \
#			$(BLDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) $(LDLAST)

platform : LCL_SRC:$(BUILDPYTHON).exe
    @ $write sys$output "Python platform build claims to be complete"


# Build the shared modules
sharedmods : LCL_SRC:$(BUILDPYTHON).exe
	@ $write sys$output "Building shared modules?"
#	case $$MAKEFLAGS in \
#	*-s*) CC='$(CC)' LDSHARED='$(BLDSHARED)' OPT='$(OPT)' LCL_SRC:$(BUILDPYTHON) -E prj_src:setup.py -q build;; \
#	*) CC='$(CC)' LDSHARED='$(BLDSHARED)' OPT='$(OPT)' LCL_SRC:$(BUILDPYTHON) -E prj_src:setup.py build;; \
#	esac

# buildno should really depend on something like LIBRARY_SRC
#lcl_src:buildno.tmp : $(PARSER_OBJS) \
#		$(OBJECT_OBJS) \
#		$(PYTHON_OBJS) \

lcl_src:buildno.tmp : $(PARSER_OBJS) \
		$(MODULE_OBJS) \
		$(SIGNAL_OBJS) \
		Prj_modules:getbuildinfo.c
	$if f$search("lcl_src:buildno.tmp") .nes. "" then \
	    copy lcl_src:buildno.tmp lcl_src:buildno.tmp
	$if f$trnlnm("BNT","LNM$PROCESS_TABLE",,"SUPERVISOR") .nes. "" \
	    then close bnt
	$if f$search("lcl_src:buildno.tmp") .eqs. "" then \
	    open/write bnt lcl_src:buildno.tmp
	$if f$trnlnm("BNT","LNM$PROCESS_TABLE",,"SUPERVISOR") .nes. "" \
	    then close bnt
	$purge lcl_src:buildno.tmp

#		$(MODOBJS) \
#

# Build static library
# avoid long command lines, same as LIBRARY_OBJS
$(LIBRARY) : $(LIBRARY)($(LIBRARY_OBJS))
	@ $ CONTINUE

lcl_parser:pgen_lib.olb : lcl_parser:pgen_lib.olb($(pobjs),$(pgobjs))
	@ $ CONTINUE

#	-rm -f $@
#	$(AR) cr $@ Prj_modules:getbuildinfo.obj
#	$(AR) cr $@ $(PARSER_OBJS)
#	$(AR) cr $@ $(OBJECT_OBJS)
#	$(AR) cr $@ $(PYTHON_OBJS)
#	$(AR) cr $@ $(MODULE_OBJS) $(SIGNAL_OBJS)
#	$(AR) cr $@ $(MODOBJS)
#	$(RANLIB) $@

#
# Build the LDLIBRARY shared image
#=======================================
$(LDLIBRARY) : $(PGEN) $(LIBRARY) lcl_parser:pgen_lib.olb \
	 prj_src:libpython_$(arch).opt lcl_src:py_ident.opt
    @ $write sys$output "Attmpting to link the $(LDLIBRARY) shared image
    link/share=$@ /symbol_table='f$parse("LCL_SRC:.STB;0","$@")'/SYSEXE \
	$(library)/lib, \
	lcl_parser:pgen_lib.olb/lib, \
	lcl_src:libpython_$(arch).opt/opt, lcl_src:py_ident.opt/opt


lcl_src:py_ident.opt : prj_src:python.opt_src prj_include:patchlevel.h
	@prj_src:SET_PYTHON_IDENT.COM $@


# 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 .LCL_SRC:$^;ld -G -o .LCL_SRC:$@ * ); \
#	    /bin/rm -rf LCL_SRC:dgux \
#	    ;; \
#	beos) \
#	    $(AR) so $(LIBRARY) $@ \
#	    ;; \
#	esac
#
# This rule is here for OPENSTEP/Rhapsody/MacOSX
#$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)/$(PYTHONFRAMEWORK) : $(LIBRARY) $(PYTHONFRAMEWORKDIR)
#	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)
	@ $write sys$output "oldsharedmods not implemented."

lcl_modules:config.c : Prj_modules:config.c_in prj_modules:config.tpu
	$(eve)$(unix_2_vms) $(MMS$SOURCE)/OUT=$(MMS$TARGET)\
	/init='f$element(1,",","$(MMS$SOURCE_LIST)")'

#		$(MAKESETUP) \
#		Prj_modules:Setup.config \
#		Prj_modules:Setup \
#		Prj_modules:Setup.local
#	$(SHELL) $(MAKESETUP) -c Prj_modules:config.c.in \
#				-s Modules \
#				Prj_modules:Setup.config \
#				Prj_modules:Setup.local \
#				Prj_modules:Setup
#	@mv config.c Modules
#	@echo "The Makefile was updated, you may need to re-run make."


Prj_modules:Setup : Prj_modules:Setup.dist
	@ $ if f$search("prj_modules:setup.") .nes. "" then \
	write sys$ouput "-----------------------------------------------"
	@ $ if f$search("prj_modules:setup.") .nes. "" then \
 	write sys$ouput \
		"Prj_modules:Setup.dist is newer than Prj_modules:Setup;"
	@ $ if f$search("prj_modules:setup.") .nes. "" then \
 	write sys$ouput \
		"check to make sure you have all the updates you"
	@ $ if f$search("prj_modules:setup.") .nes. "" then \
 	write sys$ouput \
		"need in your Prj_modules:Setup file."
	@ $ if f$search("prj_modules:setup.") .nes. "" then \
 	write sys$ouput \
		"Usually, copying Setup.dist to Setup will work."
	@ $ if f$search("prj_modules:setup.") .nes. "" then \
 	write sys$ouput \
		"-----------------------------------------------"

############################################################################
# Special rules for object files

lcl_modules:getbuildinfo.obj : Prj_modules:getbuildinfo.c lcl_src:buildno.tmp
	$(CC) $(CFLAGS1)/OBJECT=$@ Prj_modules:getbuildinfo.c

#Prj_modules:getpath.obj : Prj_modules:getpath.c #Makefile
#

#	$(CC) -c $(PY_CFLAGS) -DPYTHONPATH='"$(PYTHONPATH)"' \
#		-DPREFIX='"$(prefix)"' \
#		-DEXEC_PREFIX='"$(exec_prefix)"' \
#		-DVERSION='"$(VERSION)"' \
#		-DVPATH='"$(VPATH)"' \
#		-o $@ Prj_modules:getpath.c

lcl_modules:ccpython.obj : Prj_modules:ccpython.cc
	$(CXX) -c $(PY_CFLAGS) -o $@ Prj_modules:ccpython.cc


$(GRAMMAR_H) : $(PGEN) $(GRAMMAR_INPUT)
	    $ pgen := $$(PGEN)
	    $show sym pgen
	    $pgen $(GRAMMAR_INPUT) $(GRAMMAR_H) $(GRAMMAR_C)

# $(GRAMMAR_C) : $(PGEN) $(GRAMMAR_INPUT)
#	    $ pgen := $$(PGEN)
#	    $pgen $(GRAMMAR_INPUT) $(GRAMMAR_H) $(GRAMMAR_C)
#

$(PGEN) :	LCL_PARSER:PGENMAIN.OBJ lcl_parser:pgen_lib.olb \
			lcl_src:py_ident.opt
		LINK/exe=$@/NODEBUG LCL_PARSER:PGENMAIN.OBJ, \
			lcl_parser:pgen_lib.olb/LIB, \
			frontport__dir:frontport.opt/opt, \
			lcl_src:py_ident.opt/opt

#lcl_parser:grammar.obj :	prj_parser:grammar.c  $(PYTHON_H) \
#				$(PGENHEADERS_H) \
#				prj_include:token.h \
#				$(INCLUDE_GRAMMAR_H)
#
#lcl_parser:metagrammar.obj :	prj_parser:metagrammar.c \
#		$(PGENHEADERS_H) prj_include:metagrammar.h \
#		prj_parser:pgen.h \
#		$(INCLUDE_GRAMMAR_H)


lcl_python:compile.obj : prj_python:compile.c $(PYTHON_H) \
		prj_include:node.h prj_include:token.h \
		prj_include:compile.h prj_include:symtable.h \
		prj_include:opcode.h prj_include:structmember.h \
		$(GRAMMAR_H)

lcl_python:symtable.obj : prj_python:symtable.c $(PYTHON_H) \
		prj_include:compile.h prj_include:symtable.h \
		prj_include:structmember.h \
		$(GRAMMAR_H)

lcl_python:getplatform.obj : prj_python:getplatform.c $(PYTHON_H)


lcl_python:importdl.obj : prj_python:importdl.c $(PYTHON_H)\
		prj_python:importdl.h

#Lcl_objects:object.obj : Prj_objects:object.c Prj_objects:obmalloc.c \
#		$(PYTHON_H) prj_include:compile.h \
#		prj_include:frameobject.h prj_include:traceback.h

#Lcl_objects:unicodectype.obj :	Prj_objects:unicodectype.c \
#				Prj_objects:unicodetype_db.h
#


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

# Test the interpreter (twice, once without .pyc files, once with)
TESTOPTS=	-l
TESTPROG=	prj_lib_test:regrtest.py
TESTPYTHON=	LCL_SRC:$(BUILDPYTHON).exe -E -tt
test :		all platform
		$ testpython := $lcl_src:$(BUILDPYTHON).exe """-E""" -tt
		$ define libpython lcl_src:libpython.exe
		$ show sym testpython
		$ testpython $(TESTPROG) $(TESTOPTS)

		# find prj_lib: -name '*.py[co]' -print | xargs rm -f
		# $(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 prj_lib: -name '*.py[co]' -print | xargs rm -f
		# -$(TESTPYTHON) $(TESTPROG) $(QUICKTESTOPTS)
		$(TESTPYTHON) $(TESTPROG) $(QUICKTESTOPTS)

MEMTESTOPTS=    $(QUICKTESTOPTS) -x test_dl test___all__ test_fork1 \
		test_longexp
memtest :	all platform
		#-rm -f prj_lib_test:*.py[co]
		#-$(TESTPYTHON) $(TESTPROG) $(MEMTESTOPTS)
		$(TESTPYTHON) $(TESTPROG) $(MEMTESTOPTS)

# Install everything
install :	altinstall bininstall maninstall
		@ $write sys$output "Installation complete?"

# Install almost everything without disturbing previous versions
altinstall :	altbininstall libinstall inclinstall libainstall \
                sharedinstall oldsharedinstall
		@ $write sys$output "Alt installation complete?"

# Install shared libraries enabled by Setup
DESTDIRS=	$(exec_prefix) $(LIBDIR) $(BINLIBDEST) $(DESTSHARED)

oldsharedinstall : $(DESTSHARED) $(SHAREDMODS)
		@ $write sys$output "Oldsharedinstall not implemented."
		# @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) :
		@ $write sys$output "$(DESTSHARED) not implemented."
#		@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
	@ $write sys$output "binsinstall not implemented."
#	-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 :	lcl_src:$(BUILDPYTHON).exe
	@ $write sys$output "alt bininstal not implemented"

#	@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) lcl_src:$(BUILDPYTHON).exe $(BINDIR)/python$(VERSION)$(EXE)
#	if test -f libpython$(VERSION).so; then \
#		$(INSTALL_DATA) libpython$(VERSION).so $(LIBDIR); \
#	else	true; \
#	fi
#	if 		lcl_modules:md5module.obj \	#missing definitions
#test -f "$(DLLLIBRARY)"; then \
#		$(INSTALL_SHARED) $(DLLLIBRARY) $(BINDIR); \
#	else	true; \
#	fi

# Install the manual page
maninstall :
	@ $write sys$output "Maninstall/help install not implemented"

#	@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) prj_misc:python.man \
#		$prj_src: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 test/data \
		encodings email compiler hotshot \
		distutils distutils/command $(XMLLIBSUBDIRS) curses $(MACHDEPS)
libinstall :	lcl_src:$(BUILDPYTHON).exe prj_lib:$(PLATDIR)
	@ $ write sys$output "Libinstall not implemented."
#	@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=prj_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 prj_lib:*.py prj_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=prj_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) prj_src:LICENSE $(LIBDEST)/LICENSE.txt
#	PYTHONPATH=$(LIBDEST) \
#		LCL_SRC:$(BUILDPYTHON).exe -tt $(LIBDEST)/compileall.py -x badsyntax \
#	        $(LIBDEST)
#	PYTHONPATH=$(LIBDEST) \
#		LCL_SRC:$(BUILDPYTHON).exe -O $(LIBDEST)/compileall.py -x badsyntax $(LIBDEST)

# Create the PLATDIR source directory, if one wasn't distributed..
prj_lib:$(PLATDIR) :
	@ $write sysoutput "prj_lib:$(PLATDIR) not implemented."
#	mkdir prj_lib:$(PLATDIR)
#	cp prj_lib:plat-generic/regen prj_lib:$(PLATDIR)/regen
#	export PATH; PATH="`pwd`:$$PATH"; \
#	export PYTHONPATH; PYTHONPATH="`pwd`/Lib"; \
#	export DYLD_FRAMEWORK_PATH; DYLD_FRAMEWORK_PATH="`pwd`"; \
#	export EXE; EXE="$(BUILDEXE)"; \
#	cd prj_lib:$(PLATDIR); LCL_SRC:regen

# Install the include files
INCLDIRSTOMAKE=$(INCLUDEDIR) $(CONFINCLUDEDIR) $(INCLUDEPY) $(CONFINCLUDEPY)
inclinstall :
	@ $write sys$output "iclinstall not implemented."
#	@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 prj_include:*.h; \
#	do \
#		echo $(INSTALL_DATA) $$i $(INCLUDEPY); \
#		$(INSTALL_DATA) $$i $(INCLUDEPY); \
#	done
#	$(INSTALL_DATA) $(PYCONFIG_H) $(CONFINCLUDEPY)/pyconfig.h

# Install the library and miscellaneous stuff needed for extending/embedding
# This goes into $(exec_prefix)
LIBPL=		$(LIBP)/config
libainstall :	all
	@ $ write sys$output "libainstall not implemented."
#	@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 \
#		if test "$(PYTHONFRAMEWORKDIR)" = no-framework; then \
#			$(INSTALL_DATA) $(LDLIBRARY) $(LIBPL)/$(LDLIBRARY) ; \
#			$(RANLIB) $(LIBPL)/$(LDLIBRARY) ; \
#		else \
#			echo Skip install of $(LDLIBRARY) - use make frameworkinstall; \
#		fi; \
#	fi
#	$(INSTALL_DATA) Prj_modules:config.c $(LIBPL)/config.c
#	$(INSTALL_DATA) Prj_modules:$(MAINOBJ) $(LIBPL)/$(MAINOBJ)
#	$(INSTALL_DATA) Prj_modules:config.c.in $(LIBPL)/config.c.in
#	$(INSTALL_DATA) Makefile $(LIBPL)/Makefile
#	$(INSTALL_DATA) Prj_modules:Setup $(LIBPL)/Setup
#	$(INSTALL_DATA) Prj_modules:Setup.local $(LIBPL)/Setup.local
#	$(INSTALL_DATA) Prj_modules:Setup.config $(LIBPL)/Setup.config
#	$(INSTALL_SCRIPT) Prj_modules:makesetup $(LIBPL)/makesetup
#	$(INSTALL_SCRIPT) prj_src:install-sh $(LIBPL)/install-sh
#	@if [ -s Prj_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) Prj_modules:python.exp		\
#				$(LIBPL)/python.exp;		\
#		echo; echo "$(LIBPL)/python.exp";		\
#		$(INSTALL_SCRIPT) Prj_modules:makexp_aix	\
#				$(LIBPL)/makexp_aix;		\
#		echo "$(LIBPL)/makexp_aix";			\
#		$(INSTALL_SCRIPT) Prj_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) Prj_modules:ar_beos $(LIBPL)/ar_beos; \
#		echo "$(LIBPL)/ar_beos";			\
#		$(INSTALL_SCRIPT) Prj_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 :
	@ $write sys$output "sharedinstall not implemented."
#	LCL_SRC:$(BUILDPYTHON).exe -E prj_src:setup.py install \
#		--install-scripts=$(BINDIR) \
#		--install-platlib=$(DESTSHARED)

# Install a MacOSX framework During build (before
# setup.py), make a minimal Python.framework directory structure in the build
# directory. This framework is minimal, it doesn't contain the Lib directory
# and such, but together with some magic in Prj_modules:getpath.c it is good enough
# to run python from the install dir.
#
#FRAMEWORKDEST=$(PYTHONFRAMEWORKDIR)/Versions/$(VERSION)
#RESSRCDIR=prj_src:Mac/OSXResources/framework
#$(PYTHONFRAMEWORKDIR) : $(RESSRCDIR)/Info.plist \
#                $(RESSRCDIR)/version.plist \
#                $(RESSRCDIR)/English.lproj/InfoPlist.strings
#	@if test "$(PYTHONFRAMEWORKDIR)" = no-framework; then \
#		echo Not configured with --enable-framework; \
#		exit 1; \
#	else true; \
#	fi
#	$(INSTALL) -d -m $(DIRMODE)  $(FRAMEWORKDEST)/Resources/English.lproj
#	$(INSTALL_DATA) $(RESSRCDIR)/Info.plist $(FRAMEWORKDEST)/Resources/Info.plist
#	$(INSTALL_DATA) $(RESSRCDIR)/version.plist $(FRAMEWORKDEST)/Resources/version.plist
#	$(INSTALL_DATA) $(RESSRCDIR)/English.lproj/InfoPlist.strings \
#		$(FRAMEWORKDEST)/Resources/English.lproj/InfoPlist.strings
#	$(LN) -fs $(VERSION) $(PYTHONFRAMEWORKDIR)/Versions/Current
#	$(LN) -fs Versions/Current/Python $(PYTHONFRAMEWORKDIR)/Python
#	$(LN) -fs Versions/Current/Headers $(PYTHONFRAMEWORKDIR)/Headers
#	$(LN) -fs Versions/Current/Resources $(PYTHONFRAMEWORKDIR)/Resources
#
# On install, we re-make the framework
# structure in the install location, /Library/Frameworks/ or the argument to
# --enable-framework. If --enable-framework has been specified then we have
# automatically set prefix to the location deep down in the framework, so we
# only have to cater for the structural bits of the framework.
#
#frameworkinstall : install frameworkinfrastructureinstall
#FRAMEWORKFINALDEST=$(PYTHONFRAMEWORKINSTALLDIR)/Versions/$(VERSION)
#frameworkinfrastructureinstall :	$(LDLIBRARY)
#	@if test "$(PYTHONFRAMEWORKDIR)" = no-framework; then \
#		echo Not configured with --enable-framework; \
#		exit 1; \
#	else true; \
#	fi
#	@for i in $(FRAMEWORKFINALDEST)/Resources/English.lproj $(FRAMEWORKFINALDEST)/lib; do\
#		if test ! -d $$i; then \
#			echo "Creating directory $$i"; \
#			$(INSTALL) -d -m $(DIRMODE) $$i; \
#		else	true; \
#		fi; \
#	done
#	$(LN) -sf $(INCLUDEPY) $(FRAMEWORKFINALDEST)/Headers
#	$(INSTALL_DATA) $(RESSRCDIR)/Info.plist $(FRAMEWORKFINALDEST)/Resources/Info.plist
#	$(INSTALL_DATA) $(RESSRCDIR)/version.plist $(FRAMEWORKFINALDEST)/Resources/version.plist
#	$(INSTALL_DATA) $(RESSRCDIR)/English.lproj/InfoPlist.strings \
#		$(FRAMEWORKFINALDEST)/Resources/English.lproj/InfoPlist.strings
#	$(LN) -fs $(VERSION) $(PYTHONFRAMEWORKINSTALLDIR)/Versions/Current
#	$(LN) -fs Versions/Current/Python $(PYTHONFRAMEWORKINSTALLDIR)/Python
#	$(LN) -fs Versions/Current/Headers $(PYTHONFRAMEWORKINSTALLDIR)/Headers
#	$(LN) -fs Versions/Current/Resources $(PYTHONFRAMEWORKINSTALLDIR)/Resources
#	$(INSTALL_DATA) $(LDLIBRARY) $(PYTHONFRAMEWORKPREFIX)/$(LDLIBRARY)
#
# Build the toplevel Makefile
#Makefile.pre : Makefile.pre.in lcl_src:config.status
#	CONFIG_FILES=Makefile.pre CONFIG_HEADERS= $(SHELL) lcl_src:config.status
#	$(MAKE) -f Makefile.pre Makefile

# Run the configure script.
#lcl_src:config.status:	prj_src:configure
#	$(SHELL) prj_src:configure $(CONFIG_ARGS)
#
#.PRECIOUS : lcl_src:config.status lcl_src:$(BUILDPYTHON).exe 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 lcl_src:config.status script exists
recheck :
	@ $write sys$output "recheck not implemented."
#	$(SHELL) lcl_src:config.status --recheck
#	$(SHELL) lcl_src:config.status

# Rebuild the configure script from configure.in; also rebuild pyconfig.h.in
autoconf :
	$ set def lcl_src:
	$ @prj_src:pyconfig_h.com
#	(cd $(srcdir); autoconf)
#	(cd $(srcdir); autoheader)

# Create a tags file for vi
#tags ::
#	cd $(srcdir); \
#	ctags -w -t Prj_include:*.h; \
#	for i in $(SRCDIRS); do ctags -w -t -a $$i/*.[ch]; \
#	done; \
#	sort -o tags tags
#
# Create a tags file for GNU Emacs
#TAGS ::
#	cd $(srcdir); \
#	etags Prj_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 :
	if f$search("LCL_SRC:LIBPYTHON_*.OBJ") .nes. "" then \
		delete lcl_src:libpython_*.obj;*
	if f$search("LCL_MODULES:*.obj") .nes. "" then \
		delete lcl_modules:*.obj;*
	if f$search("LCL_OBJECTS:*.obj") .nes. "" then \
		delete lcl_objects:*.obj;*
	if f$search("LCL_PARSER:*.OBJ") .nes. "" then \
		delete lcl_parser:*.obj;*
	if f$search("LCL_PYTHON:*.obj") .nes. "" then \
		delete lcl_python:*.obj;*
	if f$search("lcl_include:graminit.h") .nes. "" then \
		delete lcl_include:graminit.h;*
	if f$search("lcl_python:graminit.c") .nes. "" then \
		delete lcl_python:graminit.c;*
	if f$search("lcl_python:dynload_shlib.c") .nes. "" then \
		delete lcl_python:dynload_shlib.c;*
	if f$search("LCL_SRC:LIBPYTHON.OLB") .nes. "" then \
		delete lcl_src:LIBPYTHON.OLB;*

clobber : clean
	if f$search("LCL_PARSER:*.obj") .nes. "" then \
		delete lcl_PARSER:*.obj;*
	if f$search("LCL_PARSER:PGEN_LIB.OLB") .nes. "" then \
		delete lcl_parser:pgen_lib.olb;*
	if f$search("LCL_PARSER:PGEN.EXE") .nes. "" then \
		delete lcl_PARSER:PGEN.EXE;*
	if f$search("lcl_src:pyconfig.h") .nes. "" then \
		delete lcl_src:pyconfig.h;*
	if f$search("lcl_modules:config.c") .nes. "" then \
		delete lcl_modules:config.c;*
	if f$search("lcl_modules:vms_config_extern.h") .nes. "" then \
		delete lcl_modules:vms_config_extern.h;*
	if f$search("lcl_modules:vms_config_static_init.h") .nes. "" then \
		delete lcl_modules:vms_config_static_init.h;*
	if f$search("lcl_src:$(BUILDPYTHON).exe") .nes. "" then \
		delete lcl_src:$(BUILDPYTHON).exe;*
	if f$search("lcl_src:LIBPYTHON.exe") .nes. "" then \
		delete lcl_src:LIBPYTHON.exe;*

#	-rm -f lcl_src:$(BUILDPYTHON).exe $(PGEN) $(LIBRARY) $(LDLIBRARY) $(DLLLIBRARY) \
#		tags TAGS \
#		config.cache config.log pyconfig.h Prj_modules:config.c
#	-rm -rf build platform

# Make things extra clean, before making a distribution:
# remove all generated files, even Makefile[.pre]
distclean : clobber
	if f$search("lcl_src:buildno.tmp") .nes. "" then \
		delete lcl_src:buildno.tmp;*
	if f$search("lcl_src:py_ident.opt") .nes. "" then \
		delete lcl_src:py_ident.opt;*

#	-rm -f core Makefile Makefile.pre buildno lcl_src:config.status \
#		Prj_modules:Setup Prj_modules:Setup.local Prj_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
	@ $ write sys$output "Not applicable to VMS."
#	nm -p $(LIBRARY) | \
#		sed -n "/ [TDB] /s/.* //p" | grep -v "^_*Py" | sort -u; \

# Find files with funny names
funny :
	$ set def lcl_src:
	$ dir /exclude=(\
		*.c,*.h,*.py,*.doc,*.txt,*.tpu,*.com,readme*.*,*.mms,*.dir \
		) [...]

#	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

# Dependencies

lcl_python:thread.obj : prj_python:thread.c $(PYTHON_H) prj_include:pythread.h

# IF YOU PUT ANYTHING HERE IT WILL GO AWAY

############################################################################
# Manually generate dependancies

lcl_src:pyconfig.h : ref_src:pyconfig.h_in
	$write sys$output "Building pyconfig.h"
	$ @prj_src:pyconfig_h.com
	$write sys$output "Done building pyconfig.h"


lcl_modules:$(MAINOBJ) : prj_modules:python.c, $(PYTHON_H)

lcl_modules:vms_config_extern.h : python_vms_modules.mms
	$ @prj_src:build_config_include_files.com

lcl_modules:config.obj : lcl_modules:config.c lcl_modules:vms_config_extern.h


lcl_modules:almodule.obj : prj_modules:almodule.c $(PYTHON_H) \
		prj_include:stringobject.h


lcl_modules:audioop.obj : prj_modules:audioop.c $(PYTHON_H)


lcl_modules:bsddbmodule.obj : prj_modules:bsddbmodule.c $(PYTHON_H) \
		prj_include:pythread.h

lcl_modules:cdmodule.obj : prj_modules:cdmodule.c $(PYTHON_H)

lcl_modules:cgensupport.obj : prj_modules:cgensupport.c $(PYTHON_H) \
		prj_modules:cgensupport.h

lcl_modules:clmodule.obj : prj_modules:clmodule.c $(PYTHON_H)


lcl_modules:dbmodule.obj : prj_modules:dbmodule.c $(PYTHON_H)

lcl_modules:fmmodule.obj : prj_modules:fmmodule.c $(PYTHON_H)

lcl_modules:fpectlmodule.obj : prj_modules:fpectlmodule.c $(PYTHON_H)

lcl_modules:fpetestmodule.obj : prj_modules:fpetestmodule.c $(PYTHON_H)

lcl_modules:gcmodule.obj : prj_modules:gcmodule.c $(PYTHON_H)

lcl_modules:getaddrinfo.obj : prj_modules:getaddrinfo.c $(PYTHON_H) \
		prj_modules:addrinfo.h

lcl_modules:getnameinfo.obj : prj_modules:getnameinfo.c \
		prj_modules:addrinfo.h

#lcl_modules:vms_getpath.obj : prj_modules:vms_getpath.c $(PYTHON_H) \
#		prj_include:osdefs.h
#

lcl_modules:getpath.obj : prj_modules:getpath.c $(PYTHON_H) \
		prj_include:osdefs.h



lcl_modules:glmodule.obj : prj_modules:glmodule.c $(PYTHON_H) \
		prj_modules:cgensupport.h

lcl_modules:imgfile.obj : prj_modules:imgfile.c $(PYTHON_H)

lcl_modules:main.obj : prj_modules:main.c $(PYTHON_H) \
		prj_include:osdefs.h prj_include:compile.h \
		prj_include:pygetopt.h


lcl_modules:newmodule.obj : prj_modules:newmodule.c $(PYTHON_H) \
		prj_include:compile.h

lcl_modules:pcremodule.obj : prj_modules:pcremodule.c $(PYTHON_H) \
		lcl_include:graminit.h \
		prj_modules:pcre.h prj_modules:pcre-int.h

lcl_modules:posixmodule.obj : prj_modules:posixmodule.c $(PYTHON_H) \
		prj_include:structseq.h

lcl_modules:puremodule.obj : prj_modules:puremodule.c $(PYTHON_H)


lcl_modules:pypcre.obj : prj_modules:pypcre.c $(PYTHON_H) \
		prj_modules:pcre-int.h \
		lcl_include:graminit.h

lcl_modules:python.obj : prj_modules:python.c $(PYTHON_H)

lcl_modules:regexmodule.obj : prj_modules:regexmodule.c $(PYTHON_H) \
		prj_modules:regexpr.h

lcl_modules:regexpr.obj : prj_modules:regexpr.c $(PYTHON_H) \
		prj_modules:regexpr.h

lcl_modules:rotormodule.obj : prj_modules:rotormodule.c $(PYTHON_H)


lcl_modules:sgimodule.obj : prj_modules:sgimodule.c $(PYTHON_H)

lcl_modules:signalmodule.obj : prj_modules:signalmodule.c $(PYTHON_H) \
		prj_include:intrcheck.h prj_include:pythread.h

lcl_modules:stropmodule.obj : prj_modules:stropmodule.c $(PYTHON_H)

lcl_modules:svmodule.obj : prj_modules:svmodule.c $(PYTHON_H) \
		prj_include:compile.h \
		prj_modules:yuv.h

lcl_modules:symtablemodule.obj : prj_modules:symtablemodule.c $(PYTHON_H) \
		prj_include:compile.h prj_include:symtable.h

lcl_modules:syslogmodule.obj : prj_modules:syslogmodule.c $(PYTHON_H)

lcl_modules:threadmodule.obj : prj_modules:threadmodule.c $(PYTHON_H) \
		prj_include:pytrhread.h


lcl_modules:xxmodule.obj : prj_modules:xxmodule.c $(PYTHON_H)

lcl_modules:xxsubtype.obj : prj_modules:xxsubtype.c $(PYTHON_H)

lcl_modules:yuvconvert.obj : prj_modules:yuvconvert.c \
		prj_modules:yuv.h

lcl_objects:abstract.obj : prj_objects:abstract.c $(PYTHON_H) \
		prj_include:structmember.h prj_include:longintrepr.h

lcl_objects:boolobject.obj : prj_objects:boolobject.c $(PYTHON_H)

lcl_objects:buffferobject.obj : prj_objects:bufferobject.c $(PYTHON_H)

lcl_objects:cellobject.obj : prj_objects:cellobject.c $(PYTHON_H)

lcl_objects:classobject.obj : prj_objects:classobject.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_objects:cobject.obj : prj_objects:cobject.c $(PYTHON_H)

lcl_objects:complexobject.obj : prj_objects:complexobject.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_objects:descrobject.obj : prj_objects:descrobject.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_objects:dictobject.obj : prj_objects:dictobject.c $(PYTHON_H)

lcl_objects:enumobject.obj : prj_objects:enumobject.c $(PYTHON_H)

lcl_objects:fileobject.obj : prj_objects:fileobject.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_objects:floatobject.obj : prj_objects:floatobject.c $(PYTHON_H)

lcl_objects:frameobject.obj : prj_objects:frameobject.c $(PYTHON_H) \
		prj_include:structmember.h \
		prj_include:compile.h prj_include:frameobject.h \
		prj_include:opcode.h

lcl_objects:funcobject.obj : prj_objects:funcobject.c $(PYTHON_H) \
		prj_include:structmember.h \
		prj_include:compile.h prj_include:eval.h \

lcl_objects:classobject.obj : prj_objects:classobject.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_objects:intobject.obj : prj_objects:intobject.c $(PYTHON_H)

lcl_objects:iterobject.obj : prj_objects:iterobject.c $(PYTHON_H)

lcl_objects:listobject.obj : prj_objects:listobject.c $(PYTHON_H)

lcl_objects:longobject.obj : prj_objects:longobject.c $(PYTHON_H) \
		prj_include:longintrepr.h

lcl_objects:methodobject.obj : prj_objects:methodobject.c $(PYTHON_H)

lcl_objects:moduleobject.obj : prj_objects:moduleobject.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_objects:object.obj : prj_objects:object.c $(PYTHON_H) \
		prj_include:compile.h prj_include:frameobject.h \
		prj_include:traceback.h prj_objects:obmalloc.c

lcl_objects:rangeobject.obj : prj_objects:rangeobject.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_objects:sliceobject.obj : prj_objects:sliceobject.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_objects:stringobject.obj : prj_objects:stringobject.c $(PYTHON_H)

lcl_objects:structseq.obj : prj_objects:structseq.c $(PYTHON_H) \
		prj_include:structmember.h prj_include:structseq.h

lcl_objects:tupleobject.obj : prj_objects:tupleobject.c $(PYTHON_H)

lcl_objects:typeobject.obj : prj_objects:typeobject.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_objects:unicodectype.obj : prj_objects:unicodectype.c $(PYTHON_H) \
		prj_include:unicodeobject.h prj_objects:unicodetype_db.h

lcl_objects:unicodeobject.obj : prj_objects:unicodeobject.c $(PYTHON_H) \
		prj_include:unicodeobject.h prj_include:unchash.h

lcl_objects:weakrefobject.obj : prj_objects:weakrefobject.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_objects:xxobject.obj : prj_objects:xxobject.c $(PYTHON_H)


lcl_parser:acceler.obj : prj_parser:acceler.c $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H) \
		prj_include:node.h prj_include:token.h prj_parser:parser.h

lcl_parser:bitset.obj : prj_parser:bitset.c $(PGENHEADERS_H) \
		prj_include:bitset.h

lcl_parser:firstsets.obj : prj_parser:firstsets.c $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H) \
		prj_include:token.h

lcl_parser:grammar.obj : prj_parser:grammar.c $(PYTHON_H) $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H) \
		prj_include:token.h

lcl_parser:grammar1.obj : prj_parser:grammar1.c $(PYTHON_H) $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H) \
		prj_include:token.h

lcl_parser:intrcheck.obj : prj_parser:intrcheck.c $(PYTHON_H)

lcl_parser:listnode.obj : prj_parser:listnode.c $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H) \
		prj_include:node.h prj_include:token.h

lcl_parser:metagrammar.obj : prj_parser:metagrammar.c $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H) \
		prj_parser:pgen.h prj_include:metagrammar.h

lcl_parser:myreadline.obj : prj_parser:myreadline.c $(PYTHON_H)

lcl_parser:node.obj : prj_parser:node.c $(PYTHON_H) \
		prj_include:node.h prj_include:errcode.h

lcl_parser:parser.obj : prj_parser:parser.c $(PYTHON_H) $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H) \
		prj_include:token.h prj_include:node.h prj_include:errcode.h

lcl_parser:parsetok.obj : prj_parser:parsetok.c $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H) \
		prj_include:token.h prj_include:node.h prj_include:errcode.h \
		prj_parser:tokenizer.h prj_parser:parser.h \
		prj_include:parsetok.h

lcl_parser:pgen.obj : prj_parser:pgen.c $(PYTHON_H) $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H) \
		prj_include:token.h prj_include:node.h \
		prj_parser:pgen.h prj_include:metagrammar.h

lcl_parser:pgenmain.obj : prj_parser:pgenmain.c $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H) \
		prj_include:node.h prj_include:parsetok.h \
		prj_parser:pgen.h

lcl_parser:printgrammar.obj : prj_parser:printgrammar.c $(PGENHEADERS_H) \
		$(INCLUDE_GRAMMAR_H)

#lcl_parser:tokenizer.obj : prj_parser:tokenizer.c $(PGENHEADERS_H) \
#		$(INCLUDE_GRAMMAR_H) \
#		prj_parser:tokenizer.h prj_include:errcode.h

lcl_parser:tokenizer_pgen.obj : prj_parser:tokenizer_pgen.c \
		prj_parser:tokenizer.c \
		$(INCLUDE_GRAMMAR_H) \
		prj_parser:tokenizer.h prj_include:errcode.h


lcl_python:dynload_shlib.c : ref_python:dynload_shlib.c
		$(eve)$(unix_2_vms) $(MMS$SOURCE)/OUT=$(MMS$TARGET)

lcl_python:$(DYNLOADFILE) : lcl_python:dynload_shlib.c $(PYTHON) \
		prj_python:importdl.h

lcl_python:errors.obj : prj_python:errors.c $(PYTHON_H)


lcl_python:bltinmodule.obj : prj_python:bltinmodule.c $(PYTHON_H) \
		prj_include:node.h prj_include:compile.h \
		prj_include:eval.h

lcl_python:CEVAL.obj : prj_python:CEVAL.C $(PYTHON_H) \
		prj_include:compile.h prj_include:frameobject.h \
		prj_include:eval.h prj_include:opcode.h \
		prj_include:structmember.h prj_include:pythread.h

lcl_python:CODECS.obj : prj_python:CODECS.c $(PYTHON_H)

lcl_python:EXCEPTIONS.obj : prj_python:EXCEPTIONS.c $(PYTHON_H) \
		prj_include:osdefs.h

lcl_python:FROZEN.obj : prj_python:FROZEN.c $(PYTHON_H)

lcl_python:FROZENMAIN.obj : prj_python:FROZENMAIN.c $(PYTHON_H)

lcl_python:FUTURE.obj : prj_python:FUTURE.c $(PYTHON_H) \
		prj_include:node.h prj_include:token.h \
		$(GRAMMER_H) prj_include:compile.h \
		prj_include:symtable.h

lcl_python:GETARGS.obj : prj_python:GETARGS.c $(PYTHON_H)

lcl_python:GETCOMPILER.obj : prj_python:GETCOMPILER.c $(PYTHON_H)

lcl_python:GETCOPYRIGHT.obj : prj_python:GETCOPYRIGHT.c $(PYTHON_H)

lcl_python:GETMTIME.obj : prj_python:GETMTIME.c $(PYTHON_H) \
		$(PYCONFIG_H)

lcl_python:GETOPT.obj : prj_python:GETOPT.c

lcl_python:GETVERSION.obj : prj_python:GETVERSION.c $(PYTHON_H) \
		prj_include:patchlevel.h

lcl_python:graminit.obj : $(grammar_h) $(PGENHEADERS_H)
	$(CC)$(CFLAGS)/object=$(MMS$TARGET) lcl_python:graminit.c

lcl_python:IMPORT.obj : prj_python:IMPORT.c $(PYTHON_H) \
		prj_include:node.h prj_include:token.h \
		prj_include:errcode.h prj_include:marshal.h \
		prj_include:compile.h prj_include:eval.h \
		prj_include:osdefs.h prj_python:importdl.h \
		prj_include:pythread.h

lcl_python:MARSHAL.obj : prj_python:MARSHAL.c $(PYTHON_H) \
		prj_include:longintrepr.h prj_include:compile.h \
		prj_include:marshal.h

lcl_python:MODSUPPORT.obj : prj_python:MODSUPPORT.c $(PYTHON_H)

lcl_python:MYSNPRINTF.obj : prj_python:MYSNPRINTF.c $(PYTHON_H)

lcl_python:MYSTRTOUL.obj : prj_python:MYSTRTOUL.c $(PYTHON_H)

lcl_python:PYFPE.obj : prj_python:PYFPE.c $(PYTHON_H) \
		prj_include:pyfpe.h

lcl_python:PYSTATE.obj : prj_python:PYSTATE.c $(PYTHON_H) \
		prj_include:pythread.h

lcl_python:PYTHONRUN.obj : prj_python:PYTHONRUN.c $(PYTHON_H) \
		$(INCLUDE_GRAMMAR_H) prj_include:node.h \
		prj_include:token.h prj_include:parsetok.h \
		prj_include:errcode.h prj_include:compile.h \
		prj_include:symtable.h prj_include:eval.h \
		prj_include:marshal.h prj_include:pythread.h

lcl_python:SIGCHECK.obj : prj_python:SIGCHECK.c $(PYTHON_H)

lcl_python:STRUCTMEMBER.obj : prj_python:STRUCTMEMBER.c $(PYTHON_H) \
		prj_include:structmember.h

lcl_python:SYSMODULE.obj : prj_python:SYSMODULE.c $(PYTHON_H) \
		prj_include:compile.h prj_include:frameobject.h \
		prj_include:osdefs.h

lcl_python:TRACEBACK.obj : prj_python:TRACEBACK.c $(PYTHON_H) \
		prj_include:compile.h prj_include:frameobject.h \
		prj_include:structmember.h prj_include:osdefs.h