default: all

include Makefile.config

CONFIGPM = lib/Config.pm lib/Config_git.pl

CONFIGPOD = lib/Config.pod

STATIC = static

# Note: MakeMaker will look for xsubpp only in specific locations

# This is one of them; but dist/ExtUtils-ParseXS isn't.

XSUBPP = lib/ExtUtils/xsubpp

# For autodoc.pl below

MANIFEST_CH = $(shell sed -e 's/\s.*//' MANIFEST | grep '\.[ch]$$')

# cpan/Pod-Perldoc/Makefile does not accept PERL_CORE=1 in MM command line,

# it needs the value to be in $ENV

export PERL_CORE=1

POD1 = $(wildcard pod/*.pod)

MAN1 = $(patsubst pod/%.pod,man/man1/%$(man1ext),$(POD1))

# Different perl version come with slightly different source lists.

# Only pick files actually present in the source tree.

# perl.c, perlmain.c, op.c, miniperl.c should not be in this list

src = av.c scope.c doop.c doio.c dump.c gv.c hv.c mg.c reentr.c mro_core.c

src += perly.c pp.c pp_hot.c pp_ctl.c pp_sys.c regexec.c

src += utf8.c sv.c taint.c toke.c util.c deb.c run.c universal.c

src += pad.c globals.c keywords.c perlio.c perlapi.c numeric.c

src += mathoms.c locale.c pp_pack.c pp_sort.c caretx.c dquote.c $(time64.c)

src += pp_type.c xsutils.c # cperl

src += $(wildcard builtin.c peep.c class.c)

src += $(wildcard regcomp.c regcomp_*.c)

src += $(mallocsrc)

obj = $(patsubst %.c,%$o,$(wildcard $(src)))

static_modules = $(patsubst %,%/pm_to_blib,$(fullpath_static_ext))

dynamic_modules = $(patsubst %,%/pm_to_blib,$(fullpath_dynamic_ext))

nonxs_modules = $(patsubst %,%/pm_to_blib,$(fullpath_nonxs_ext))

disabled_dynamic = $(patsubst %,%/pm_to_blib,$(disabled_dynamic_ext))

disabled_nonxs = $(patsubst %,%/pm_to_blib,$(disabled_nonxs_ext))

# perl module names for static mods

static_pmn = $(shell for e in $(fullpath_static_ext) ; do grep '^NAME =' $$e/Makefile | cut -d' ' -f3 ; done)

dynaloader_o = $(patsubst %,%$o,$(dynaloader))

modules = $(fullpath_nonxs_ext) $(fullpath_dynamic_ext) $(fullpath_static_ext)

disabled = $(disabled_nonxs_ext) $(disabled_dynamic_ext)

# ---[ perl-cross patches ]-----------------------------------------------------

# Note: the files are patched in-place, and so do not make valid make-rules

# Because of this, they are only applied loosely, allowing the user to intervene

# if need be.

CROSSPATCHES = $(shell find cnf/diffs/$(patchset) -name '*.patch')

CROSSPATCHED = $(patsubst %.patch,%.applied,$(CROSSPATCHES))

# Use `patch --follow-symlinks` for out-of-tree builds. Regular builds should

# stick with just `patch` as --follow-symlinks is a GNU option that is not

# supported by other implementations.

cpatch = $(shell test -h MANIFEST && echo patch --follow-symlinks || echo patch)

.PHONY: crosspatch

crosspatch: $(CROSSPATCHED)

# A minor fix for buildroot, force crosspatching when running "make perl modules"

# instead of "make all" (can't use a PHONY target here due to rebuilds).

miniperlmain$O: $(CROSSPATCHED)

# Original versions are not saved anymore; patch generally takes care of this,

# and if that fails, reaching for the source tarball is the safest option.

$(CROSSPATCHED): %.applied: %.patch

$(cpatch) -p1 -i $< && touch $@

# ---[ common ]-----------------------------------------------------------------

# Do NOT delete any intermediate files

# (mostly Makefile.PLs, but others can be annoying too)

.SECONDARY:

# Force full patching before any building starts. Als, force early building

# of miniperl -- not really necessary, but makes the build process more logical.

# No reason to try CC if HOSTCC fails.

#

# Dynaloader is also built separately as race failures have been observed.

all:

$(MAKE) crosspatch

$(MAKE) miniperl$X

$(MAKE) dynaloader

$(MAKE) perl$x nonxs_ext utilities extensions pods

config.h: config.sh config_h.SH

CONFIG_H=$@ CONFIG_SH=$< ./config_h.SH

xconfig.h: xconfig.sh config_h.SH

CONFIG_H=$@ CONFIG_SH=$< ./config_h.SH

# Prevent the following rule from overwriting Makefile by running Makefile.SH

Makefile:

touch $@

%: %.SH config.sh

./$*.SH

# ---[ host/miniperl ]----------------------------------------------------------

miniperl$X: miniperlmain$O $(obj:$o=$O) opmini$O perlmini$O

$(HOSTCC) $(HOSTLDFLAGS) -o $@ $(filter %$O,$^) $(HOSTLIBS)

miniperlmain$O: miniperlmain.c patchlevel.h

generate_uudmap$X: generate_uudmap.c

$(HOSTCC) $(HOSTCFLAGS) -o $@ $^

ifneq ($O,$o)

%$O: %.c xconfig.h

$(HOSTCC) $(HOSTCFLAGS) -c -o $@ $<

endif

globals$O: uudmap.h bitcount.h

uudmap.h bitcount.h mg_data.h: generate_uudmap$X

./generate_uudmap uudmap.h bitcount.h mg_data.h

opmini.c: op.c

cp -f $^ $@

opmini$O: opmini.c

$(HOSTCC) $(HOSTCFLAGS) -DPERL_EXTERNAL_GLOB -c -o $@ $<

perlmini.c: perl.c

cp -f $^ $@

perlmini$O: perlmini.c

$(HOSTCC) $(HOSTCFLAGS) -DPERL_IS_MINIPERL -c -o $@ $<

# Do not re-generate perly.c and perly.h even if they appear out-of-date.

# Use "make regen_perly" to force update.

# The following rule cancels implicit .y -> .c make would use otherwise

%.c: %.y

regen_perly:

perl regen_perly.pl

# ---[ site/perl ]--------------------------------------------------------------

ifeq ($(useshrplib),true)

ifeq ($(soname),)

perl$x: LDFLAGS += -Wl,-rpath,$(archlib)/CORE

endif

endif # or should it be "else"?

perl$x: LDFLAGS += -Wl,-E

perl$x: perlmain$o $(LIBPERL) $(static_modules) static.list ext.libs

$(eval extlibs=$(shell cat ext.libs))

$(eval statars=$(shell cat static.list))

$(CC) $(LDFLAGS) -o $@ $(filter %$o,$^) $(LIBPERL) $(statars) $(LIBS) $(extlibs)

%$o: %.c config.h

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

globals.o: uudmap.h

perlmain.c: ext/ExtUtils-Miniperl/pm_to_blib $(patsubst %,%/Makefile,$(fullpath_static_ext)) | miniperl$X

./miniperl_top -MExtUtils::Miniperl -e 'writemain(\"$@", @ARGV)' $(dynaloader) $(static_pmn)

ext.libs: Makefile.config $(patsubst %,%/Makefile,$(fullpath_static_ext)) | $(static_modules) miniperl$X

./miniperl_top extlibs $(static_pmn) > $@

static.list: Makefile.config $(patsubst %,%/Makefile,$(fullpath_static_ext)) | $(static_modules) miniperl$X

./miniperl_top statars $(static_pmn) > $@

# ---[ site/library ]-----------------------------------------------------------

libperl: $(LIBPERL)

$(LIBPERL): op$o perl$o $(obj) $(dynaloader_o)

# It would be better to test for static-library suffix here, but the suffix

# is not used explicitly anywhere else, including in -Dlibperl=

# So let's make it so that useshrplib controls the kind of the library

# regardless of the library name.

# This is in-line with gcc and ld behavior btw.

ifneq ($(soname),)

$(LIBPERL): LDDLFLAGS += -Wl,-soname -Wl,$(soname)

ifneq ($(soname),$(LIBPERL))

$(LIBPERL): $(soname)

$(soname):

ln -sf $(LIBPERL) $@

endif

endif

ifeq ($(useshrplib),true)

$(LIBPERL):

$(CC) $(LDDLFLAGS) -o $@ $(filter %$o,$^) $(LIBS)

else

$(LIBPERL):

$(AR) cru $@ $(filter %$o,$^)

$(RANLIB) $@

endif

perl.o: git_version.h

config-pm: $(CONFIGPM)

configpod: $(CONFIGPOD)

# Both git_version.h and lib/Config_git.pl are built

# by make_patchnum.pl.

git_version.h lib/Config_git.pl: make_patchnum.pl | miniperl$X

./miniperl_top make_patchnum.pl

lib/Config.pm lib/Config_heavy.pl lib/Config.pod: config.sh cflags \

lib/Config_git.pl Porting/Glossary | miniperl$X

./miniperl_top configpm

# NOT used by this Makefile, replaced by miniperl_top

# Avoid building.

lib/buildcustomize.pl: write_buildcustomize.pl | miniperl$X

./miniperl$X -Ilib $< > $@

# ---[ Modules ]----------------------------------------------------------------

# The rules below replace make_ext script used in the original

# perl build chain. Some host-specific functionality is lost.

# Check miniperl_top to see how it works.

#

# note make -C mod-dir does not always update pm_to_blib which we use

# as the completion stamp; that's why `touch $@`.

#

$(nonxs_modules) $(disabled_nonxs): %/pm_to_blib: | %/Makefile

$(MAKE) -C $(dir $@) PERL_CORE=1 LIBPERL=$(LIBPERL)

@touch $@

DynaLoader$o: | ext/DynaLoader/pm_to_blib

@if [ ! -f ext/DynaLoader/DynaLoader$o ]; then rm $<; echo "Stale pm_to_blib, please re-run make"; false; fi

cp ext/DynaLoader/DynaLoader$o $@

ext/DynaLoader/pm_to_blib: %/pm_to_blib: | %/Makefile

$(MAKE) -C $(dir $@) PERL_CORE=1 LIBPERL=$(LIBPERL) LINKTYPE=static

@touch $@

ext/DynaLoader/Makefile: config.h | dist/lib/pm_to_blib

$(static_modules): %/pm_to_blib: | %/Makefile $(nonxs_tgt)

$(MAKE) -C $(dir $@) PERL_CORE=1 LIBPERL=$(LIBPERL) LINKTYPE=static static

@touch $@

$(dynamic_modules) $(disabled_dynamic): %/pm_to_blib: | %/Makefile

$(MAKE) -C $(dir $@) PERL_CORE=1 LIBPERL=$(LIBPERL) LINKTYPE=dynamic

@touch $@

# Make sure re.pm and lib.pm are available for Makefile.PLs to use

lib/re.pm: ext/re/re.pm

cp -f ext/re/re.pm lib/re.pm

lib/lib.pm: dist/lib/pm_to_blib

dist/lib/Makefile: dist/lib/Makefile.PL cflags config.h $(CONFIGPM) | miniperl$X

$(eval top=$(shell echo $(dir $@) | sed -re 's![^/]+!..!g'))

cd $(dir $@) && $(top)miniperl_top -I$(top)lib Makefile.PL \

PERL_CORE=1 LIBPERL_A=$(LIBPERL) PERL="$(top)miniperl_top"

preplibrary = miniperl$X lib/re.pm lib/lib.pm

%/Makefile: %/Makefile.PL cflags config.h $(CONFIGPM) | $(XSUBPP) $(preplibrary)

$(eval top=$(shell echo $(dir $@) | sed -re 's![^/]+!..!g'))

cd $(dir $@) && $(top)miniperl_top -I$(top)lib Makefile.PL \

INSTALLDIRS=perl INSTALLMAN1DIR=none INSTALLMAN3DIR=none \

PERL_CORE=1 LIBPERL_A=$(LIBPERL) PERL="$(top)miniperl_top"

# Allow building modules by typing "make cpan/Module-Name"

.PHONY: $(modules) $(disabled)

$(modules) $(disabled): %: %/pm_to_blib

.PHONY: nonxs_ext dynamic_ext static_ext extensions modules

nonxs_ext: $(nonxs_modules)

dynamic_ext: $(dynamic_modules)

static_ext: $(static_modules)

extensions: cflags nonxs_ext dynamic_ext static_ext

modules: extensions

# Some things needed to make modules

%/Makefile.PL: | miniperl$X

./miniperl_top make_ext_Makefile.pl $@

cflags: cflags.SH

sh $<

makefiles: $(patsubst %,%/Makefile,$(modules))

dynaloader: $(dynaloader_o)

$(ppport)/ppport.h: $(ppport)/pm_to_blib

@test -f $@

cpan/Unicode-Normalize/Makefile: lib/unicore/CombiningClass.pl

dist/Unicode-Normalize/Makefile: lib/unicore/CombiningClass.pl

# mktables does not touch the files unless they need to be rebuilt,

# which confuses make.

pod/perluniprops.pod: lib/unicore/CombiningClass.pl

lib/unicore/CombiningClass.pl: $(CONFIGPM)

./miniperl_top lib/unicore/mktables -w -C lib/unicore -P pod -maketest -makelist -p

# The following rules ensure that modules listed in mkppport.lst get

# their ppport.h installed. There's a bunch of comments in that file,

# which must be skipped.

# 5.36.0: the list now includes Devel-PPPort itself which we have

# a dedicated rule for, so that one must be excluded as well.

mkppport_lst = $(shell cat mkppport.lst | grep '^[a-z]' | grep -v Devel-PPPort)

$(patsubst %,%/pm_to_blib,$(mkppport_lst)): %/pm_to_blib: %/ppport.h

# This one does not fit the above pattern

cpan/YAML-LibYAML/pm_to_blib: cpan/YAML-LibYAML/LibYAML/ppport.h

$(patsubst %,%/ppport.h,$(mkppport_lst)): $(ppport)/ppport.h

cp -f $< $@

lib/ExtUtils/xsubpp: dist/ExtUtils-ParseXS/lib/ExtUtils/xsubpp

cp -f $< $@

# No ExtUtils dependencies here because that's where they come from

cpan/ExtUtils-ParseXS/Makefile cpan/ExtUtils-Constant/Makefile: \

%/Makefile: %/Makefile.PL cflags $(CONFIGPM) | $(preplibrary)

$(eval top=$(shell echo $(dir $@) | sed -re 's![^/]+!..!g'))

cd $(dir $@) && $(top)miniperl_top Makefile.PL PERL_CORE=1 PERL=$(top)miniperl_top

cpan/List-Util/pm_to_blib: | ext/DynaLoader/pm_to_blib

ext/Pod-Functions/pm_to_blib: | cpan/Pod-Simple/pm_to_blib

cpan/Pod-Simple/pm_to_blib: | cpan/Pod-Escapes/pm_to_blib

$(dynamic_modules): | ext/DynaLoader/pm_to_blib dist/ExtUtils-CBuilder/pm_to_blib

dist/ExtUtils-CBuilder/pm_to_blib: | cpan/Perl-OSType/pm_to_blib cpan/Text-ParseWords/pm_to_blib

# ---[ modules cleanup & rebuilding ] ------------------------------------------

.PHONY: modules-reset modules-makefiles modules-clean

modules-reset:

$(if $(nonxs_modules), rm -f $(nonxs_modules))

$(if $(static_modules), rm -f $(static_modules))

$(if $(dynamic_modules), rm -f $(dynamic_modules))

$(if $(disabled_nonxs), rm -f $(disabled_nonxs))

$(if $(disabled_dynamic), rm -f $(disabled_dynamic))

modules-makefiles: makefiles

modules-clean: clean-modules

# ---[ Misc ]-------------------------------------------------------------------

.PHONY: utilities

utilities: miniperl$X $(CONFIGPM)

$(MAKE) -C utils all

# ---[ modules lists ]----------------------------------------------------------

modules.done: modules.list

echo -n > modules.done

-cat $< | (while read i; do $(MAKE) -C $$i && echo $$i >> modules.done; done)

modules.pm.list: modules.done

-cat $< | (while read i; do find $$i -name '*.pm'; done) > $@

modules.list: $(CONFIGPM) $(MODLISTS) cflags

./modconfig_all

# ---[ pods ]-------------------------------------------------------------------

pod/perltoc.pod: modules extra.pods \

pod/perlapi.pod \

pod/perlintern.pod \

pod/perlmodlib.pod \

pod/perluniprops.pod \

pod/$(perldeltapod)

pods: pod/perltoc.pod

# This is done on every build; the results depends on all installed pod files

# and the exact list of dependencies is difficult to obtain.

pod/perltoc.pod: pod/buildtoc | miniperl$X

./miniperl_top -f pod/buildtoc -q

pod/perlapi.pod: pod/perlintern.pod

pod/perlintern.pod: autodoc.pl embed.fnc | miniperl$X

./miniperl_top autodoc.pl

pod/perlmodlib.pod: pod/perlmodlib.PL MANIFEST | miniperl$X

./miniperl_top pod/perlmodlib.PL -q

pod/$(perldeltapod): pod/perldelta.pod

ln -sf $(notdir $<) $@

ifdef perlcdeltapod

pod/$(perlcdeltapod): pod/perlcdelta.pod

ln -sf $(notdir $<) $@

pod/perltoc.pod: pod/$(perlcdeltapod)

endif

extra.pods: | miniperl$X

-@test ! -f extra.pods || rm -f `cat extra.pods`

-@rm -f extra.pods

-@for x in `grep -l '^=[a-z]' README.* | grep -v README.vms` ; do \

nx=`echo $$x | sed -e "s/README\.//"`; \

ln -sf ../$$x "pod/perl"$$nx".pod" ; \

echo "pod/perl"$$nx".pod" >> extra.pods ; \

done

# ---[ test ]-------------------------------------------------------------------

.PHONY: test

test:

cd t/ && ln -sf ../perl . && LD_LIBRARY_PATH=$(PWD) ./perl harness

# ---[ install ]----------------------------------------------------------------

.PHONY: install install.perl install.sym install.pod

META.yml: Porting/makemeta Porting/Maintainers.pl Porting/Maintainers.pm miniperl$X

./miniperl_top $<

install:

$(MAKE) install.perl

$(MAKE) install.man

install.perl: installperl | miniperl$X

./miniperl_top installperl --destdir=$(DESTDIR) $(INSTALLFLAGS) $(STRIPFLAGS)

-@test ! -s extras.lst || $(MAKE) extras.install

ifneq ($(perlname),perl)

-rm -f $(DESTDIR)$(installbin)/$(perlname)$(version)

ln -sf $(perlname) $(DESTDIR)$(installbin)/perl

else

-rm -f $(DESTDIR)$(installbin)/$(perlname)$(version)

endif

install.sym: # deprecated

install.man: installman pod/perltoc.pod | miniperl$X

./miniperl_top installman --destdir=$(DESTDIR) $(INSTALLFLAGS)

# ---[ testpack ]---------------------------------------------------------------

.PHONY: testpack

testpack: TESTPACK.tar.gz

TESTPACK.list: | miniperl$X TESTPACK.px

./miniperl$X TESTPACK.px TESTPACK.list TESTPACK

TESTPACK.tar.gz: TESTPACK.list

tar -zcvf $@ -T $<

# ---[ clean ]------------------------------------------------------------------

# clean-modules must go BEFORE clean-generated-files because it depends on config.h!

.PHONY: clean clean-obj clean-generated-files clean-subdirs clean-modules clean-testpack

clean: clean-obj clean-modules clean-generated-files clean-subdirs clean-testpack

clean-obj:

-test -n "$o" && rm -f *$o

-test -n "$O" && rm -f *$O

clean-subdirs:

$(MAKE) -C utils clean

# assuming modules w/o Makefiles were never built and need no cleaning

clean-modules: clean-ppport

./modclean

# Cleaning Devel-PPPort but leaving ppport.h in other places messes up

# dependency tracking for that file.

clean-ppport:

rm -f $(patsubst %,%/ppport.h,$(mkppport_lst))

clean-generated-files:

-rm -f uudmap.h opmini.c generate_uudmap$X bitcount.h $(CONFIGPM)

-rm -f git_version.h lib/re.pm lib/Config_git.pl

-rm -f perlmini.c perlmain.c

-rm -f config.h xconfig.h

-rm -f pod/perlmodlib.pod

-rm -f ext.libs static.list

-rm -f $(patsubst %,%/ppport.h,$(mkppport_lst))

-rm -f $(ppport)/ppport.h $(ppport)/PPPort.pm

clean-testpack:

-rm -fr TESTPACK

-rm -f TESTPACK.list