# ~/public_html/src/bsd/fixes/FreeBSD/src/jhs/share/mk/berklix2.mk
# http://berklix.com/~jhs/src/bsd/fixes/FreeBSD/src/jhs/share/mk/berklix2.mk
# Called from near all ~jhs Makefiles by .include
# Copied to: /site/usr/share/mk/berklix2.mk
# by cd /site/usr/share/mk; make
# Copied to other sites by /site/Makefile & cd ~jhs/public_html;make int2remo
# Author & Copyright "Julian H. Stacey" 1995-2018
# Releasable as per BSD. Additions & fixes welcome, preferably diff -c
# See Also: berklix.mk
# What It Is: Macros for BSD Makefiles, to make extra file types,
# pretty much of any type I''ve ever needed.
# Took me till 2018 to state what it is.
# Maybe it wasnt on the Internet way back?
# so didnt need to be stated.
# !!CAUTION EDITING!! THIS FILE CONTAINS EVIL 8 BIT HIGH BYTES
# Take caution if using tool eg Source code repository etc,
# that might only allow ASCII & amputate the top 8th bit.
.if defined (BERKLIX2_DEFINED) #{
# Do nothing, avoid many complaints of
# warning: duplicate script for target
# when a Makefile accidentally has 2 of
# .include
.else #}{
BERKLIX2_DEFINED=YES
# Makefile macros for text data, to specify default dependencies & rules for:
# Formats: Tex Groff, Html, Postscript, Fax, etc
# Tools: Latex, Groff, Le, tbl, soelim, etc
# WYSIWYG Combination Tools: {vi + ghostview}, {vi + chimera},
# {vi + xfig}
# JJLATER split this 5000 line file into several:
# - macro names
# - suffixes
# - special single label "all:" & "_all:" etc
# - normal single labels such as "pdf:" & "ps:"
# - converter rules such as: ".rof.ps:"
# JJLATER Add something to keep all the null for loops quiet
# when doing a make clean.
# JJLATER Add something to SUBDIR to stop clean descending into .xvpics
# that has no Makefile
#------------------------------------------------------------------------------
# Where a Makefile uses both
# .include
# .include
# they should be in the above order, bsd.prog.mk before berklix.mk so that the
# clean: dependency works, for instance
# ~jhs/public_html/src/bsd/jhs/bin/public/satelite/
# will not clean the satelite.o if it''s the other way round.
#------------------------------------------------------------------------------
# Analysis of make operators.
# Definition Command Issued Result
# XX := ls *.ps ls *.ps ls *.ps
# XX := `ls *.ps` `ls *.ps` aa.ps bb.ps date.ps
# XX := echo *.ps echo *.ps echo *.ps
# XX := `echo *.ps` `echo *.ps` aa.ps bb.ps date.ps
# XX != ls *.ps aa.ps bb.ps aa.ps bb.ps
# XX != `ls *.ps` null null
# XX != echo *.ps aa.ps bb.ps aa.ps bb.ps
# XX != `echo *.ps` null null
# zz:
# date > date.ps
# echo x${XX}x
# It''s better to use `ls *.l_rof` than `echo *.l_rof`
# for the case where there is no *.l_rof
#------------------------------------------------------------------------------
# PDF_TO_TIFF_FORCE="YES"
# Normaly leave undefined or normal direction, converting
# .tiff scan images to .pdf. Only define if occasionaly you
# want the reverse direction, extracting a .tiff from a .pdf,
# if eg a PDF is received by email or a pdf manual downloaded,
# where you want to extract text from a TIFF using OCR.
# (Some manufacturers provide nice PDF manuals with text strings
# copyable by mouse,
# but some only provide bit map PDFs one can''t mouse copy notes from ).
# --
# We can not have both rules .tiff.pdf & .pdf.tiff present at the same
# time, else if xx.pdf exists, 'make xx.tiff' freaks with error:
# "Graph cycles through xx.tiff"
#------------------------------------------------------------------------------
# Suffix precedence order for default rules.
# Ref. 4.9-RELEASE/usr/share/doc/psd/12.make/paper.ascii.gz.
# - A precursor line containing just ".SUFFIXES:" would flush all suffixes
# before defining my own, but I''m not that draconian.
# - The more to the left a suffix is, the higher priority it has to be source
# rather than some other source, when choosing a source to make a dependency.
# Whether the dependency is to left or right of source make no difference
# I believe. If both Thing.high & Thing.low exist, with either of these
# .SUFFIXES: .high .low .out
# .SUFFIXES: .out .high .low
# Thing.out will be built from Thing.high.
# I think it''s also nice (though not necessary) to list in this order:
# .SUFFIXES: .high .low .out
# - I have not checked the next SUFFIX line complies with the above requirement.
# - On the precedence order of .pnm & .png:
# - .pnm was added 2019-01-17
# - Xv emits .pnm
# - .pnm 30 x bulkier compared to telling xsane to save jpg
# - These both exist in /usr/local/bin:
# link pngtopnm -> pngtopam
# file pnmtopng
# - man pnmtopng: with grayscale, @low max vals distortion happens.
# - man pngtopnm: obsoleted by pngtopam, part of Netpbm,
# - http://netpbm.sourceforge.net/doc/index.html
# All of the programs work with a set of graphics formats
# called the "netpbm" formats. Specifically, these formats
# are pbm, pgm, ppm, and pam. The first three of these are
# sometimes known generically as "pnm".
# - https://en.wikipedia.org/wiki/Portable_Network_Graphics
# Was developed as an improved, non-patented replacement for .gif
# For transferring images on the Internet, not for
# professional-quality print graphics
# - https://en.wikipedia.org/wiki/Netpbm_format
# - I assume .pnm is master raw source data, so .pnm precedes derivative .png
# - /usr/ports/graphics/netpbm
.if ( defined(PDF_TO_TIFF_FORCE) ) #{{
.SUFFIXES: .pdf .tiff
.elif ( defined(TIFF_TO_JPG_FORCE) ) #}{
.SUFFIXES: .tiff .jpg
.else # }{
# Do NOT sort this list alphabeticaly !!
# I moved .jpg above .tif to convert scans received in .jpg from jes@.
.SUFFIXES: \
.m4 \
.l_rof \
.e_rof \
.rof \
.l_lmth \
.e_lmth \
.lmth \
.l_html \
.e_html \
.html \
.vhtml \
.l_tex \
.e_tex \
.tex \
.fig \
.vfig \
.fax \
.JPG \
.jpg \
.TIF \
.TIFF \
.tif \
.tiff \
.pnm \
.PNG \
.png \
.dvi \
.eps \
.ps \
.epsi \
.PDF \
.pdf \
.vps \
.Vps \
.txt \
.txt_e \
.txt_g \
.lst \
.dos \
.latin1 \
.pcl_ps \
.pcl_rof \
.ppm \
.wav \
.epson \
.bjccolor \
.bjc600 \
.vbjccolor \
.vbjc600 \
.cdj670 \
.vcdj670 \
.gif \
.gif_transparent \
.gif_rotl \
.gif_rotr \
.m4a \
.mpeg4 \
.mp2 \
.mp3 \
.endif # }}
# EXTRACTION:
# First we create 2 (or more) sym links, one per language to extract,
# so each language has a visible rebuild dependency when the master changes.
# Then we make language extracted files.
# .l_rof: A dual language master file, to be extracted in le format,
# to 2 or more seperate .rof language files,
# (le extracts 1 language from several, including common chunks).
# .e_rof: Symbolic links (one per language) pointing to a common
# multiple language .l_rof file in ``le'' format. Example:
# document_e.e_rof@ -> document.l_rof
# document_g.e_rof@ -> document.l_rof
# .rof A file to be text formatted by groff to output eg postscript.
# .l_lmth: A dual language .lmth to be extracted with ``le'' to produce 2
# .lmth files
# .e_lmth Symbolic links (one per language) to a common .l_lmth file.
# used by ``le'' to produce 2 or more .lmth files.
# .lmth: Needs something prepending & appending before producing .html.
# .bjc600 is bjc monochrome,
# .bjccolor is bjc colour
# A .bjccolor seems to print black, even if the black tank
# is removed, making the black from a combination of colours,
# so unless the electronics is detecting tank absence &
# compensating, it may regularly be doing that, in whih case,
# best to put in the other black only tank.
# .pdf & .ps
# I raised priority of PDF above PS, as eg a downloaded PDF (GEA Prog,
# with a few pictures in colour) of 150K became 3.8M of .ps & shrank
# again to 111K of .pcl.
# ghif
# Only places that manipulate gifs are ~/public_html/gifs/
# http://www.berklix.com/vsl/Makefile
# http://www.berklix.com/vsl/card.gif.comment
# Fax order is problematic: there are both fax2ps & ps2fax commands.
#------------------------------------------------------------------------------
T_BERKLIX = "berklix2.mk:"
T_PRE_EXIST = "Symbolic linking to pre-existing"
# Tag in typescript log to assist searching.
T_END = "${T_BERKLIX} ENDING TARGET"
T_START_RULE = "${T_BERKLIX} STARTING RULE"
T_START_TARGET = "TARGET"
# DEBUG_BERKLIX_MK = yes
# DEBUG_BERKLIX_MK: Uncomment to debug this macro file,
# Or better, as this .mk file is exported to web & may be use by others,
# & dont want them upset, eg: make DEBUG_BERKLIX_MK=yes pdf
# (Plain DEBUG not used as other FreeBSD (non jhs@) Makefiles use that name.)
# Never let a filename use an equal symbol in it:
# EQUAL1 etc are to ensure no = character is in file name,
# else it is seen by make as a macro assertion, & make sees no name
# of anything to make, & with no argument, goes recursive, calling make all.
# JJLATER I should extend usage of EQUAL1 etc to check before ${GS} is invoked.
# as ${GS} also does not like = in file names.
.if ! defined (DEBUG_BERKLIX_MK) #{
ECHO_BUILD = true
ECHO_END = true
ECHO_START = true
# CMD_FOR_BUILD: 2019-02-27 I reverted from "-for" to "for"
# to allow EQUAL1 etc to fail
CMD_FOR_BUILD = for
CMD_FOR_CLEAN = for
ECHO_DOING = true
T_END = ""
T_START_RULE = ""
T_START_TARGET = ""
EQUAL1 = true
EQUAL2 = ; echo
EQUAL3 = | grep -v =
.else #}{
ECHO_BUILD = echo
ECHO_END = echo
ECHO_START = echo
# CMD_FOR_BUILD: 2019-02-27 I reverted from "-for" to "for"
# to allow EQUAL1 etc to fail
CMD_FOR_BUILD = for
CMD_FOR_CLEAN = for
ECHO_DOING = echo
T_END = "${T_BERKLIX} in ${.CURDIR} ENDING TARGET"
T_START_RULE = "${T_BERKLIX} in ${.CURDIR} STARTING RULE"
T_START_TARGET = "TARGET"
EQUAL1 = echo -n "Checking no equal symbol = in filename " ; echo
EQUAL2 = ; echo
EQUAL3 = | grep -v =
.endif #}
EQUAL4 = || ( echo -n "Fatal: Equal symbol = not allowed in filename " ; echo
EQUAL5 = ; false )
#------------------------------------------------------------------------------
BERKLIX_MK = /usr/share/mk/berklix.mk
PATH_MK = http://www.berklix.com/src/share/mk
PATH_CMPD = http://www.berklix.com/~jhs/src/bsd/jhs/bin/public/cmpd/
PATH_LE = http://www.berklix.com/~jhs/src/bsd/jhs/bin/public/le/
# PATH_LE = http://www.berklix.com/src/bin/le
# Till 2014_09_10 i had the above abbreviated PATH_LE, which worked cos for
# some reason I cant recall, I also had:
# /site/usr/local/www/Data/virtual/berklix.com/src/bin
# le@ -> ../../jhs/src/bsd/jhs/bin/public/le
PATH_NOTAIL = http://www.berklix.com/~jhs/src/bsd/jhs/bin/public/notail/
BERKLIX_SRC = ${PATH_MK}/berklix.mk
BERKLIX2_SRC = ${PATH_MK}/berklix2.mk
A4_HEIGHT_I = 11.6944 # from man gs, if vertical portrait
A4_WIDTH_I = 8.26389 # from man gs, if vertical portrait
# Converting this from inches to centimetres
# echo "826389 254 * p" | dc # 20.9902806
# echo "116944 254 * p" | dc # 29.703776
# Though actually this looses precision, as I guess A4 is defined in metric,
# & further, the A0 A1 A2 A3 A4 series have some geometric folding basis
# off a metre ? So one could be infinitely precise in [milli]metres etc,
# not imperial.
# xsane full defaults to 21.59 x 29.72
# So I would assume one wants 20.99 x 29.70
# but xsane a4 portrait sets to 21.00 x 21.00 for some unknown reason
ACROREAD = /usr/local/bin/acroread
CMPD = /usr/local/bin/cmpd
DJPEG = /usr/local/bin/djpeg
DVIPS = /usr/local/bin/dvips
DVIPS2ASCII = /usr/local/bin/dvips2ascii
FAX2PS = /usr/local/bin/fax2ps
FFMPEG = /usr/local/bin/ffmpeg
FIG2DEV = /usr/local/bin/fig2dev
GHOSTVIEW = /usr/local/bin/ghostview
GIFTOPNM = /usr/local/bin/giftopnm
GS = /usr/local/bin/gs
GV = /usr/local/bin/gv
GV_ARGS = -media a4 -antialias
INFO = /usr/local/bin/info
INFOKEY = /usr/local/bin/infokey
INSTALL-INFO = /usr/local/bin/install-info
LAME = /usr/local/bin/lame
LATEX = /usr/local/bin/latex
LATEX2HTML = /usr/local/bin/latex2html
LE = /usr/local/bin/le
MAKEINFO = /usr/local/bin/makeinfo
NOTAIL = /usr/local/bin/notail
PDF2PS = /usr/local/bin/pdf2ps
PDFLATEX = /usr/local/bin/pdflatex
PNMCROP = /usr/local/bin/pnmcrop
PNMQUANT = /usr/local/bin/pnmquant
PNMROTATE = /usr/local/bin/pnmrotate
PNMSCALE = /usr/local/bin/pnmscale
# See also pnmscalefixed pnmenlarge
PNMTOJPEG = /usr/local/bin/pnmtojpeg
PNGTOPNM = /usr/local/bin/pngtopnm
PNMTOPNG = /usr/local/bin/pnmtopng
PNMTOPS = /usr/local/bin/pnmtops
PAMTOTIFF = /usr/local/bin/pamtotiff
PPMTOGIF = /usr/local/bin/ppmtogif
PS2EPSI = /usr/local/bin/ps2epsi
PS2PDF = /usr/local/bin/ps2pdf
PS2PDF_LAND_ARGS = -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -r600 -g7017x4958
# -g7017x4958 come from
# A4_HEIGHT_I = 11.6944 # from man gs, if vertical portrait
# A4_WIDTH_I = 8.26389 # from man gs, if vertical portrait
# & I assumed a resolution of 600 dpi
# 7016.64
# 4958.334
PSNUP = /usr/local/bin/psnup
PSSELECT = /usr/local/bin/psselect
PSTOPNM = /usr/local/bin/pstopnm
PSTOPS = /usr/local/bin/pstops
PSTOPS_FRNT =1L(1w,0.000000h)+2L(1w,0.333333h)+3L(1w,0.666667h)
PSTOPS_BACK =4R(0w,1.000000h)+5R(0w,0.666667h)+0R(0w,0.333333h)
# PSTOPS_BACK Screws up: 2nd page upside down, & I can''t fix it.
PSTOPS_ARGS =6:$(PSTOPS_FRNT),$(PSTOPS_BACK)
# PSTOPS_ARGS Specific to the BIM3 column leaflet, for now.
TESSERACT = /usr/local/bin/tesseract
TEXI2DVI = /usr/local/bin/texi2dvi
TEXI2PDF = /usr/local/bin/texi2pdf
TEXINDEX = /usr/local/bin/texindex
TIDYAFTERVI = ${HOME}/bin/.sh/tidy_after_vi
CHECKLINKSAFTERVI = ${HOME}/bin/.sh/checklinks_after_vi
TIDY = /usr/local/bin/tidy4
TIFFINFO = /usr/local/bin/tiffinfo
TIFF2PS = /usr/local/bin/tiff2ps
TIFF2PS_ERR = "tiff2ps fails on current with: Inconsistent value of es: 0."
TIFF2PS_ARGS = -p -a
# -p added to TIFF2PS_ARGS 2014-03-24 as FreeBSD 9.2-RELEASE with
# /usr/local/bin/tiff2ps -a -h11.6944 -w8.26389 file_with_3_pages.tiff \
# > /dev/null
# Warns: "-e and -a: \
# Warning: Cannot generate Encapsulated Postscript for multiple images."
# However -p is a problem in ~/job/groff/card/paper when converting
# berklix_com_jhs.png > .jpg> > .tif > .ps > .eps
# As the .ps becomes a full page, which screws up my business card.
# In that case I get round it with qrencode -t EPS
ASPELL= = /usr/local/bin/aspell
SPELLAFTERVI = ${HOME}/bin/.sh/spell_after_vi
ISPELL = /usr/local/bin/ispell
# TIFF2PS_ARGS_LANDSCAPE = -r 180 -h${A4_WIDTH_I} -w${A4_HEIGHT_I}
# -r 180 cos I put my landscapes in my scanner with top of paper on right.
# I notice gv t.ps builds image from bottom of page up, so maybe other people
# consider a landscape top to start on left edge ?
TIFF2PS_ARGS_LANDSCAPE = -h${A4_WIDTH_I} -w${A4_HEIGHT_I}
TIFF2PS_ARGS_PORTRAIT = -h${A4_HEIGHT_I} -w${A4_WIDTH_I}
VLC = /usr/local/bin/vlc
XDVI = /usr/local/bin/xdvi
XEARTH = /usr/local/bin/xearth
XPDF = /usr/local/bin/xpdf
# SPELL != ${HOME}/bin/.sh/spell_which
# This working shell script was previously used, instead of the .if
# further below, I have not delteted it as I might want it later,
# but as others adoping the berklix overlay will not have that shell
# script installed, I internalise it below as a macro.
# #!/bin/sh
# # ~jhs/bin/.sh/spell_which
# # Called by ~jhs/src/bsd/fixes/FreeBSD/src/gen/share/mk/berklix.mk
# # & by ~jhs/bin/.sh/spell_after_vi
#
# if test -e /usr/local/bin/ispell
# then
# # echo $0 debug sees /usr/local/bin/ispell
# echo "${T_BERKLIX} /usr/local/bin/ispell"
# # spell -x Don''t create a backup file.
# elif test -e /usr/local/bin/aspell
# then
# # echo $0 debug sees /usr/local/bin/aspell
# echo "${T_BERKLIX} /usr/local/bin/aspell"
# # aspell -c = check.
# else
# echo "${T_BERKLIX} Warning: $0 no /usr/local/bin/ispell or /usr/local/bin/aspell"
# echo /usr/bin/true
# fi
# exit 0
.if exists(${ISPELL})
SPELL = ispell
.elif exists(${ASPELL})
SPELL = ${ASPELL}
.else
SPELL = false spell_undefined_in_berklix2.mk
.endif
TMAC_DIR = /usr/share/tmac
UMLAUTS_INC = ${TMAC_DIR}/umlauts.rof
COMMON_INC = ${TMAC_DIR}/common.rof
# JJLATER consider merging both umlauts.rof + common.rof to berklix.rof
#------------------------------------------------------------------------------
# Later possible additions:
# - html2ascii using lynx -dump
# - latex2html using tth
# - latex2ps direct
# - latex2pdf direct
#------------------------------------------------------------------------------
# Keep this as first target,
.if !target(all) #{
all:
@${ECHO_START} "${T_START_RULE} all ${T_START_TARGET} $@ {"
make _all
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(_all) #{
_all:
@${ECHO_START} "${T_START_RULE} _all ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make le
@# le is not on dependency line cos for debuging I want to see
@# @${ECHO_START} ${T_START_RULE} _all
@# ---
make all2
@# all2 cannot be on dependency line, as we need to re-evaluate
@# dependencies after links are made by le
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(all2) #{
all2:
@${ECHO_START} "${T_START_RULE} all2 ${T_START_TARGET} $@ {"
make l_lmth e_lmth lmth l_html e_html html l_rof e_rof rof \
l_tex e_tex tex dvi pdf # ps
.if defined(ALL) #{
make ${ALL}
.endif #}
@# No: epson txt lst dos latin1 fax fig
@# Too big to generate by default: bjccolor bjc600
.endif #}
@${ECHO_END} "${T_END} $@ }"
#------------------------------------------------------------------------------
.if !target(install) #{
install:
@# Dummy, to satisfy a standard recursive make from $(HOME)
@echo "${T_BERKLIX} a dummy $@ label in `pwd`"
.endif #}
#------------------------------------------------------------------------------
.if !target(obj) #{
obj:
@# Dummy, to satisfy a standard recursive make from $(HOME)
@echo "${T_BERKLIX} a dummy $@ label in `pwd`"
.endif #}
#------------------------------------------------------------------------------
.if !target(cleandir) #{
cleandir:
@# Dummy, to satisfy a standard recursive make from $(HOME)
@echo "${T_BERKLIX} a dummy $@ label in `pwd`"
.endif #}
#------------------------------------------------------------------------------
SIG_REOPEN = SIGUSR1
# SIG_REOPEN is the signal(2) sent for a
# reload by {ghostview, chimera, xfig}.
#------------------------------------------------------------------------------
# Explanation of `ls *.rof` type usage:
# If a directory just has just 2 files photo.ps & photo.pcl
# then the command
# for i
# in `ls *.rof` ; rm `basename $i .rof`.ps ; done
# will unwantedly
# remove photo.ps, as *.rof gets passed to $i as un unevaluated
# literal, this also happens with for i in `echo *.rof`,
# however
# with for i in `ls *.rof` it is safe.
# The 2> /dev/null was
# added to stop too many noisy for loops emitting eg:
# ls:
# *.l_html: No such file or directory
#------------------------------------------------------------------------------
# The above gives a full rooted path name of source which when I am generating
# .html for web I might not wish to publicise, as it might give insight
# for crackers.
DONT_EDIT = "DO NOT EDIT ${.TARGET} Built from `basename ${.IMPSRC}`"
#------------------------------------------------------------------------------
# Only define FOR* eg FOR_L_ROF in individual Makefiles
# in the
# unlikely event you dont want the for loops to run
# on all *.l_rof
# or to generate output files such as .ps files
# Example: I do define
# FOR_L_ROF in my cv directory
# as I have special rules there.
.if !defined(FOR_TXT) #{
FOR_TXT := `ls *.txt 2> /dev/null`
.endif #}
.if !defined(FOR_CDJ670) #{
FOR_CDJ670 := `ls *.cdj670 2> /dev/null`
.endif #}
.if !defined(FOR_BJC600) #{
FOR_BJC600 := `ls *.bjc600 2> /dev/null`
.endif #}
.if !defined(FOR_BJCCOLOR) #{
FOR_BJCCOLOR := `ls *.bjccolor 2> /dev/null`
.endif #}
.if !defined(FOR_DVI) #{
FOR_DVI := `ls *.dvi 2> /dev/null`
.endif #}
.if !defined(FOR_EPSI) #{
FOR_EPSI := `ls *.epsi 2> /dev/null`
.endif #}
.if !defined(FOR_EPSON) #{
FOR_EPSON := `ls *.epson1 2> /dev/null`
.endif #}
.if !defined(FOR_E_HTML) #{
FOR_E_HTML := `ls *.e_html 2> /dev/null`
.endif #}
.if !defined(FOR_E_LMTH) #{
FOR_E_LMTH := `ls *.e_lmth 2> /dev/null`
.endif #}
.if !defined(FOR_E_ROF) #{
FOR_E_ROF := `ls *.e_rof 2> /dev/null`
.endif #}
.if !defined(FOR_E_TEX) #{
FOR_E_TEX := `ls *.e_tex 2> /dev/null`
.endif #}
.if !defined(FOR_FAX) #{
FOR_FAX := `ls *.fax 2> /dev/null`
.endif #}
# I believe fax is a tiff format, whether it''s bidirectionally 1:1 format
# & tiff always == fax I dont know. Comment welcome.
# scanjet outputs .tiff using scanimage in
# http://www.berklix.com/scanjet/
.if !defined(FOR_TIFF_UCASE) #{
FOR_TIFF_UCASE := `ls *.TIFF 2> /dev/null`
.endif #}
.if !defined(FOR_TIF_UCASE) #{
FOR_TIF_UCASE := `ls *.TIF 2> /dev/null`
.endif #}
.if !defined(FOR_TIFF) #{
FOR_TIFF := `ls *.tiff 2> /dev/null`
.endif #}
# tiffsplit outputs .tif
.if !defined(FOR_TIF) #{
FOR_TIF := `ls *.tif 2> /dev/null`
.endif #}
.if !defined(FOR_FIG) #{
FOR_FIG := `ls *.fig 2> /dev/null`
.endif #}
.if !defined(FOR_HTML) #{
FOR_HTML := `ls *.html 2> /dev/null`
.endif #}
.if !defined(FOR_LATIN1) #{
FOR_LATIN1 := `ls *.latin1 2> /dev/null`
.endif #}
.if !defined(FOR_LMTH) #{
FOR_LMTH := `ls *.lmth 2> /dev/null`
.endif #}
.if !defined(FOR_L_HTML) #{
FOR_L_HTML := `ls *.l_html 2> /dev/null`
.endif #}
.if !defined(FOR_L_LMTH) #{
FOR_L_LMTH := `ls *.l_lmth 2> /dev/null`
.endif #}
.if !defined(FOR_L_ROF) #{
FOR_L_ROF := `ls *.l_rof 2> /dev/null`
.endif #}
.if !defined(FOR_L_TEX) #{
FOR_L_TEX := `ls *.l_tex 2> /dev/null`
.endif #}
.if !defined(FOR_M4) #{
FOR_M4 := `ls *.m4 2> /dev/null`
.endif #}
.if !defined(FOR_PCL_ROF) #{
FOR_PCL_ROF := `ls *.pcl_rof 2> /dev/null`
.endif #}
.if !defined(FOR_PCL_PS) #{
FOR_PCL_PS := `ls *.pcl_ps 2> /dev/null`
.endif #}
.if !defined(FOR_PS) #{
FOR_PS := `ls *.ps 2> /dev/null`
.endif #}
.if !defined(FOR_PNG) #{
FOR_PNG := `ls *.png 2> /dev/null`
.endif #}
.if !defined(FOR_PNM) #{
FOR_PNM := `ls *.pnm 2> /dev/null`
.endif #}
.if !defined(FOR_JPG) #{
FOR_JPG := `ls *.jpg 2> /dev/null`
.endif #}
.if !defined(FOR_PNG_UCASE) #{
FOR_PNG_UCASE := `ls *.PNG 2> /dev/null`
.endif #}
.if !defined(FOR_PDF) #{
FOR_PDF := `ls *.pdf 2> /dev/null`
.endif #}
.if !defined(FOR_PDF_UCASE) #{
FOR_FIG := `ls *.PDF 2> /dev/null`
.endif #}
.if !defined(FOR_ROF) #{
FOR_ROF := `ls *.rof 2> /dev/null`
.endif #}
.if !defined(FOR_TEX) #{
FOR_TEX := `ls *.tex 2> /dev/null`
.endif #}
.if !defined(FOR_TIFF2PS) #{
FOR_TIFF2PS := `ls *.tiff 2> /dev/null`
.endif #}
.if !defined(FOR_GROFF_HTML_JUNK) #{
FOR_GROFF_HTML_JUNK := `ls groff-html-[0-9]*-[0-9]*.png 2> /dev/null`
.endif #}
LANGS ?= e g
# LANGS e g for english & german, used by le -e & le -g, & also used in
# filename_e.tex file_g.ps etc.
# Sometimes the le program is not used to filter languages, but other things,
# eg ~/job/groff/card/paper/Makefile uses it for different people``s
# business cards.
.if !defined(FOR_WAV) #{
FOR_WAV := `ls *.wav 2> /dev/null`
.endif #}
.if !defined(FOR_PS) #{
FOR_MP3 := `ls *.mp3 2> /dev/null`
.endif #}
#------------------------------------------------------------------------------
# SINGLE TARGETS LE EXTRACTORS
# Example: label rof generates all *.rof files.
#------------------------------------------------------------------------------
.if !target(le) #{
le:
@${ECHO_START} "${T_START_RULE} le ${T_START_TARGET} $@ {"
.if defined(SUBDIR) #{
@# Allow recursion.
@# Occasionally I need to manualy call le to recurse down
@# before then calling clean. As a clean on its own wont otherwise see
@# longer names to purge.
@echo "Next line used to degrade host power on /site/usr/local/www/Data/virtual/berklix.com so commented to just a suggestion"
@echo "Suggestion make _SUBDIR"
.endif #}
make l_ e_
@# This creates seperate language copies of any multi language masters
@# JJLATER do I need le to depend on e_ as well as l_ ?
@# Probably not, now I''ve seperated naming for link & extract stages.
@${ECHO_END} "${T_END} $@ }"
.endif #}
l_:
@${ECHO_START} "${T_START_RULE} l_ ${T_START_TARGET} $@ {"
make l_rof l_lmth l_html l_tex
@${ECHO_END} "${T_END} $@ }"
e_:
@${ECHO_START} "${T_START_RULE} e_ ${T_START_TARGET} $@ {"
make e_rof e_lmth e_html e_tex
@${ECHO_END} "${T_END} $@ }"
#------------------------------------------------------------------------------
# MORE SINGLE TARGETS IN ALPHABETIC ORDER
#------------------------------------------------------------------------------
.if !target(bjccolor) #{
bjccolor:
@${ECHO_START} "${T_START_RULE} bjccolor ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make ps
${CMD_FOR_BUILD} i in ${FOR_PS} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .ps`.bjccolor ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(cdj670) #{
cdj670:
@${ECHO_START} "${T_START_RULE} cdj670 ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make ps
${CMD_FOR_BUILD} i in ${FOR_PS} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .ps`.cdj670 ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(bjc600) #{
bjc600:
@${ECHO_START} "${T_START_RULE} bjc600 ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make ps
${CMD_FOR_BUILD} i in ${FOR_PS} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .ps`.bjc600 ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(epsi) #{
epsi:
@${ECHO_START} "${T_START_RULE} epsi ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make ps
${CMD_FOR_BUILD} i in ${FOR_PS} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .ps`.epsi ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean) #{
clean:
@${ECHO_START} "${T_START_RULE} clean ${T_START_TARGET} $@ {"
@make _clean
@${ECHO_END} "${T_END} $@ }"
.endif #}
.if !target(_clean) #{
_clean: \
clean_gif clean_pcl_rof clean_pcl_ps clean_cdj670 clean_bjccolor \
clean_bjc600 clean_epson clean_dos clean_latin1 clean_txt \
clean_lst clean_vfig clean_fig clean_vps clean_aux clean_css \
clean_log clean_Vps clean_pdf clean_epsi clean_ps clean_mp3 clean_fax \
clean_txt clean_tiff clean_tif clean_jpg clean_png clean_pnm clean_dvi \
clean_grohtml clean_vhtml clean_html clean_e_html clean_l_html \
clean_lmth clean_e_lmth clean_l_lmth clean_tex clean_e_tex \
clean_l_tex clean_rof clean_e_rof clean_l_rof
@# Clean the lowest dependency first, then crawl back to top source, so
@# sub rules do not have to know every source a .pcl can come from
@# clean_grohtml may not be in correct order above.
@# ------------------------
@# pre 2018-05-16:
@# rm -f ${CLEAN}
.if exists( ${CLEAN} ) #{
rm -f ${CLEAN}
.else # }{
@# echo "Nothing extra to clean."
.endif #}
@# JJLATER test -e add an eval here of ${CLEAN} & if empty, skip it.
@# ------------------------
@# rm -rf .xvpics
.endif #}
#------------------------------------------------------------------------------
# Clean Explanations. Take example clean_ps:
# a smarter replacement for "rm *.ps"
# (can''t be done that crudely as we have .ps masters eg photos in docs).
# It cleans all .ps that could be rebuilt from an exisiting immediate
# source. (ie existence of a .rof would cause a .ps of the same name
# to be removed). More distant sources
# such as a .e_rof with no .rof, also get a .ps removed, to ensure a
# clean really does remove all it can, even if an intermediate file
# is missing, The body of the rule does not itself clean things a .ps
# could be used to generate, it sets dependencies to do that.
#------------------------------------------------------------------------------
.if !target(clean_txt) #{
clean_txt:
@${ECHO_START} "${T_START_RULE} clean_txt ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.txt ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_M4} ; do \
rm -f `basename $$i .m4`.txt ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.txt ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.txt ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.txt ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.txt ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.txt ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIFF} ; do \
rm -f `basename $$i .tiff`.txt `basename $$i .tiff`.txt_e ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIFF} ; do \
rm -f `basename $$i .tiff`.txt `basename $$i .tiff`.txt_g ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIF} ; do \
rm -f `basename $$i .tif`.txt `basename $$i .tif`.txt_e ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIF} ; do \
rm -f `basename $$i .tif`.txt `basename $$i .tif`.txt_g ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_bjc600) #{
clean_bjc600:
@${ECHO_START} "${T_START_RULE} clean_bjc600 ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_PS} ; do \
rm -f `basename $$i .ps`.bjc600 ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.bjc600 \
`basename $$i .rof`.[0-9]*.bjc600 ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.bjc600 \
`basename $$i .tex`.[0-9]*.bjc600 ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.bjc600 \
`basename $$i .e_rof`_$$j.[0-9]*.bjc600 ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.bjc600 \
`basename $$i .l_rof`_$$j.[0-9]*.bjc600 ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.bjc600 \
`basename $$i .e_tex`_$$j.[0-9]*.bjc600 ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.bjc600 \
`basename $$i .l_tex`_$$j.[0-9]*.bjc600 ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_cdj670) #{
clean_cdj670:
@${ECHO_START} "${T_START_RULE} clean_cdj670 ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_PS} ; do \
rm -f `basename $$i .ps`.cdj670 ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.cdj670 \
`basename $$i .rof`.[0-9]*.cdj670 ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.cdj670 \
`basename $$i .tex`.[0-9]*.cdj670 ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.cdj670 \
`basename $$i .e_rof`_$$j.[0-9]*.cdj670 ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.cdj670 \
`basename $$i .l_rof`_$$j.[0-9]*.cdj670 ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.cdj670 \
`basename $$i .e_tex`_$$j.[0-9]*.cdj670 ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.cdj670 \
`basename $$i .l_tex`_$$j.[0-9]*.cdj670 ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_bjccolor) #{
clean_bjccolor:
@${ECHO_START} "${T_START_RULE} clean_bjccolor ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_PS} ; do \
rm -f `basename $$i .ps`.bjccolor ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.bjccolor \
`basename $$i .rof`.[0-9]*.bjccolor ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.bjccolor \
`basename $$i .tex`.[0-9]*.bjccolor ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.bjccolor \
`basename $$i .e_rof`_$$j.[0-9]*.bjccolor ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.bjccolor \
`basename $$i .l_rof`_$$j.[0-9]*.bjccolor ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.bjccolor \
`basename $$i .e_tex`_$$j.[0-9]*.bjccolor ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.bjccolor \
`basename $$i .l_tex`_$$j.[0-9]*.bjccolor ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_aux) #{
clean_aux:
@${ECHO_START} "${T_START_RULE} clean_aux ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.aux ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.aux ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.aux ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_css) #{
clean_css:
@${ECHO_START} "${T_START_RULE} clean_css ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.css ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.css ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.css ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_log) #{
clean_log:
@${ECHO_START} "${T_START_RULE} clean_log ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.log ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.log ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.log ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_dos) #{
clean_dos:
@${ECHO_START} "${T_START_RULE} clean_dos ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_TXT} ; do \
rm -f `basename $$i .txt`.dos ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.dos ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.dos ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.dos ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.dos ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.dos ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.dos ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_dvi) #{
clean_dvi: clean_ps
@${ECHO_START} "${T_START_RULE} clean_dvi ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.dvi ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.dvi ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.dvi ; \
done ; \
done
@# JJLATER maybe sometime add a ROF rule, but I do not currently
@# generate .dvi images from .rof.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_epson) #{
clean_epson:
@${ECHO_START} "${T_START_RULE} clean_epson ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_PS} ; do \
rm -f `basename $$i .ps`.epson ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.epson \
`basename $$i .rof`.[0-9]*.epson ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.epson \
`basename $$i .tex`.[0-9]*.epson ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.epson \
`basename $$i .e_rof`_$$j.[0-9]*.epson ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.epson \
`basename $$i .l_rof`_$$j.[0-9]*.epson ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.epson \
`basename $$i .e_tex`_$$j.[0-9]*.epson ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.epson \
`basename $$i .l_tex`_$$j.[0-9]*.epson ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_e_html) #{
clean_e_html:
@${ECHO_START} "${T_START_RULE} clean_e_html ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_L_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_lmth`_$$j.e_html ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_e_rof) #{
clean_e_rof:
@${ECHO_START} "${T_START_RULE} clean_e_rof ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.e_rof ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_e_lmth) #{
clean_e_lmth:
@${ECHO_START} "${T_START_RULE} clean_e_lmth ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_L_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_lmth`_$$j.e_lmth ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_e_tex) #{
clean_e_tex:
@${ECHO_START} "${T_START_RULE} clean_e_tex ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.e_tex ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_fax) #{
clean_fax:
@${ECHO_START} "${T_START_RULE} clean_fax ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# A fax file is an absolute master, received by a fax modem.
@# I''ll ignore for now the fact one Can create a fax file using
@# hylafax tools etc.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_tiff) #{
clean_tiff:
@${ECHO_START} "${T_START_RULE} clean_tiff ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# A tiff file is usually an absolute master, received from a scanner.
@# but may sometime be a symbolic link to a .tif,
@# where tiffsplit has split mutiple pages from an ADF block.
@${CMD_FOR_CLEAN} i in ${FOR_TIFF_UCASE} ; do \
rm -f `basename $$i .tif`.tiff ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIF_UCASE} ; do \
rm -f `basename $$i .tif`.tiff ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIF} ; do \
rm -f `basename $$i .tif`.tiff ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_JPG} ; do \
rm -f `basename $$i .jpg`.tiff ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_tif) #{
clean_tif:
@${ECHO_START} "${T_START_RULE} clean_tif ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# A tif file is usually an absolute master, received from a scanner
@# but may also be from tiffplit or pamtotiff.
@${CMD_FOR_CLEAN} i in ${FOR_JPG} ; do \
rm -f `basename $$i .jpg`.tif ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_fig) #{
clean_fig:
@${ECHO_START} "${T_START_RULE} clean_fig ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# A fig file is an absolute master, made by human, not machine.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_html) #{
clean_html: clean_ps clean_vhtml
@${ECHO_START} "${T_START_RULE} clean_html ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.html ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.html ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.html ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_HTML} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_html`_$$j.html ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_HTML} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_html`_$$j.html ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_LMTH} ; do \
rm -f `basename $$i .lmth`.html ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_lmth`_$$j.html ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_lmth`_$$j.html ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.html ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.html ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.html ; \
done ; \
done
@#
@# groff-html-[0-9]*-[0-9]*.png are junk from groff -Thtml
@# I used to do this:
@# rm -f groff-html-[0-9]*-[0-9]*.png groff-html-[0-9]*-[0-9]*.gif
@# but it''s just noise if nothing is there, so now do it silently:
@${CMD_FOR_CLEAN} i in ${FOR_GROFF_HTML_JUNK} ; do \
rm -f $$i ; \
done
.if ( target(index.html) ) #{
.if defined (DEBUG_BERKLIX_MK)
@echo "${T_BERKLIX} Rebuild rule exists, so removing index.html"
.endif
rm -f index.html
.else
.if defined (DEBUG_BERKLIX_MK)
@echo "${T_BERKLIX} No rebuild rule for index.html, so not not removing it."
.endif
.endif #}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_grohtml) #{
clean_grohtml:
@# echo "$@ in berklix2.mk new 2018-05-16"
@# Problem each Makefile in:
@# job/project/concept_engineering
@# job/project/netswitch/bills
@# job/project/redknee/company/roff/bills
@# job/project/redknee/company/roff/other
@# job/project/redknee/money
@# job/project/utimaco/admin/bills
@# tech
@# Used to have (before I removed text) in this order:
@# clean:
@# -rm grohtml-*.png
@# .include
@# but that stopped other clean ups in this file being called.
@# ----
@# I suppose grohtml-*.png are created by one or both of
@# /usr/bin/post-grohtml /usr/bin/pre-grohtml
@# called from target .rof.html:
.if exists( ${.CURDIR}/grohtml-*.png ) #{
ls -l ${.CURDIR}/grohtml-*.png
@echo "SUGGESTION: rm ${.CURDIR}/grohtml-*.png
.else # }{
@#echo "No ${.CURDIR}/grohtml-*.png"
.endif #}
.if exists( grohtml-*.png ) #{
ls -l grohtml-*.png
@echo "SUGGESTION: rm grohtml-*.png
.else # }{
@#echo "No ${.CURDIR}/grohtml-*.png"
.endif #}
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_latin1) #{
clean_latin1:
@${ECHO_START} "${T_START_RULE} clean_latin1 ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.latin1 ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.latin1 ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.latin1 ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_l_html) #{
clean_l_html:
@${ECHO_START} "${T_START_RULE} clean_l_html ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# An l_html file is an absolute master, made by human, not machine.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_l_lmth) #{
clean_l_lmth:
@${ECHO_START} "${T_START_RULE} clean_l_lmth ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# An l_lmth file is an absolute master, made by human, not machine.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_l_rof) #{
clean_l_rof:
@${ECHO_START} "${T_START_RULE} clean_l_rof ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# An l_rof file is an absolute master, made by human, not machine.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_l_tex) #{
clean_l_tex:
@${ECHO_START} "${T_START_RULE} clean_l_tex: ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# An l_tex file is an absolute master, made by human, not machine.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_lmth) #{
clean_lmth:
@${ECHO_START} "${T_START_RULE} clean_lmth ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@make clean_html
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
rm -f `basename $$i .e_rof`.lmth ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.lmth ; \
done
@# Assume EG fred.lmth can be rebuilt from fred.le.
@# next bit not useful yet.
@# Clean up after aborted wysiwyg edits of .lmth files
@${CMD_FOR_CLEAN} i in ${FOR_E_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_lmth`_$$j.lmth ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_lmth`_$$j.lmth ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_lst) #{
clean_lst:
@${ECHO_START} "${T_START_RULE} clean_lst ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.lst ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.lst ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.lst ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .L_rof`_$$j.lst ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.lst ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.lst ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_pcl_rof) #{
clean_pcl_rof:
@${ECHO_START} "${T_START_RULE} clean_pcl_rof ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# ${CMD_FOR_CLEAN} i in ${FOR_PS} ; do \
@# rm -f `basename $$i .ps`.pcl_rof ; \
@# done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.pcl_rof \
`basename $$i .rof`.[0-9]*.pcl_rof ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.pcl_rof \
`basename $$i .tex`.[0-9]*.pcl_rof ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.pcl_rof \
`basename $$i .e_rof`_$$j.[0-9]*.pcl_rof ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.pcl_rof \
`basename $$i .l_rof`_$$j.[0-9]*.pcl_rof ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.pcl_rof \
`basename $$i .e_tex`_$$j.[0-9]*.pcl_rof ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.pcl_rof \
`basename $$i .l_tex`_$$j.[0-9]*.pcl_rof ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_pcl_ps) #{
clean_pcl_ps:
@${ECHO_START} "${T_START_RULE} clean_pcl_ps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_PS} ; do \
rm -f `basename $$i .ps`.pcl_ps ; \
done
@# These rof can 1st generate a .ps
@# so it is valid to delete these .pcl_ps
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.pcl_ps \
`basename $$i .rof`.[0-9]*.pcl_ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.pcl_ps \
`basename $$i .tex`.[0-9]*.pcl_ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.pcl_ps \
`basename $$i .e_rof`_$$j.[0-9]*.pcl_ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.pcl_ps \
`basename $$i .l_rof`_$$j.[0-9]*.pcl_ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.pcl_ps \
`basename $$i .e_tex`_$$j.[0-9]*.pcl_ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.pcl_ps \
`basename $$i .l_tex`_$$j.[0-9]*.pcl_ps ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_gif) #{
clean_gif:
@${ECHO_START} "${T_START_RULE} clean_gif ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_PS} ; do \
rm -f `basename $$i .ps`.gif ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.gif \
`basename $$i .rof`.[0-9]*.gif ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.gif \
`basename $$i .tex`.[0-9]*.gif ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.gif \
`basename $$i .e_rof`_$$j.[0-9]*.gif ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.gif \
`basename $$i .l_rof`_$$j.[0-9]*.gif ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.gif \
`basename $$i .e_tex`_$$j.[0-9]*.gif ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.gif \
`basename $$i .l_tex`_$$j.[0-9]*.gif ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_ps) #{
# Do not call clean_pcl_rof, as a .ps is not allowed
# to make a.pcl_rof
clean_ps:
@${ECHO_START} "${T_START_RULE} clean_ps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@make clean_pcl_ps clean_epson clean_cdj670 clean_bjccolor \
clean_bjc600 clean_vps
@${CMD_FOR_CLEAN} i in ${FOR_PDF} ; do \
rm -f `basename $$i .pdf`.ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.ps `basename $$i .rof`.[0-9]*.ps ; \
done
@# The .[0-9]*.ps are single page images.
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.ps \
`basename $$i .e_rof`_$$j.[0-9]*.ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.ps \
`basename $$i .l_rof`_$$j.[0-9]*.ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.ps `basename $$i .tex`.[0-9]*.ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.ps \
`basename $$i .e_tex`_$$j.[0-9]*.ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.ps \
`basename $$i .l_tex`_$$j.[0-9]*.ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_FAX} ; do \
rm -f `basename $$i .fax`.ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIFF} ; do \
rm -f `basename $$i .tiff`.ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIF} ; do \
rm -f `basename $$i .tif`.ps ; \
done
@${ECHO_DOING} Zap .ps files created by xfig from .fig
@${CMD_FOR_CLEAN} i in ${FOR_FIG} ; do \
echo xxxxxx.$i ; \
echo ZAP `basename $$i .fig`.ps ; \
rm -f `basename $$i .fig`.ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_M4} ; do \
rm -f `basename $$i .m4`.ps ; \
done
@# Zap .ps files created manually by a browser
@${CMD_FOR_CLEAN} i in ${FOR_HTML} ; do \
rm -f `basename $$i .html`.ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_HTML} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_html`_$$j.ps \
`basename $$i .e_html`_$$j.[0-9]*.ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_HTML} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_html`_$$j.ps \
`basename $$i .l_html`_$$j.[0-9]*.ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_LMTH} ; do \
rm -f `basename $$i .lmth`.ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_html`_$$j.ps \
`basename $$i .e_html`_$$j.[0-9]*.ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_html`_$$j.ps \
`basename $$i .l_html`_$$j.[0-9]*.ps ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_epsi) #{
# .epsi created by eg ${PS2EPSI}
clean_epsi:
@${ECHO_START} "${T_START_RULE} clean_epsi ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@make clean_pcl_ps clean_epson clean_cdj670 clean_bjccolor \
clean_bjc600 clean_vps
@${CMD_FOR_CLEAN} i in ${FOR_PDF} ; do \
rm -f `basename $$i .pdf`.epsi ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.epsi `basename $$i .rof`.[0-9]*.epsi ; \
done
@# The .[0-9]*.epsi are single page images.
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.epsi \
`basename $$i .e_rof`_$$j.[0-9]*.epsi ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.epsi \
`basename $$i .l_rof`_$$j.[0-9]*.epsi ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.epsi `basename $$i .tex`.[0-9]*.epsi ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.epsi \
`basename $$i .e_tex`_$$j.[0-9]*.epsi ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.epsi \
`basename $$i .l_tex`_$$j.[0-9]*.epsi ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_FAX} ; do \
rm -f `basename $$i .fax`.epsi ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIFF} ; do \
rm -f `basename $$i .tiff`.epsi ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIF} ; do \
rm -f `basename $$i .tif`.epsi ; \
done
@# Zap .epsi files created by xfig from .fig
@${CMD_FOR_CLEAN} i in ${FOR_FIG} ; do \
rm -f `basename $$i .fig`.epsi ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_M4} ; do \
rm -f `basename $$i .m4`.epsi ; \
done
@# Zap .epsi files created manually by a browser
@${CMD_FOR_CLEAN} i in ${FOR_HTML} ; do \
rm -f `basename $$i .html`.epsi ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_HTML} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_html`_$$j.epsi \
`basename $$i .e_html`_$$j.[0-9]*.epsi ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_HTML} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_html`_$$j.epsi \
`basename $$i .l_html`_$$j.[0-9]*.epsi ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_LMTH} ; do \
rm -f `basename $$i .lmth`.epsi ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_html`_$$j.epsi \
`basename $$i .e_html`_$$j.[0-9]*.epsi ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_html`_$$j.epsi \
`basename $$i .l_html`_$$j.[0-9]*.epsi ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_png) #{
clean_png:
@${ECHO_START} "${T_START_RULE} clean_png ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_PNG_UCASE} ; do \
rm -f `basename $$i .PNG`.png ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_PNM} ; do \
rm -f `basename $$i .PNM`.png ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_pnm) #{
clean_pnm:
@${ECHO_START} "${T_START_RULE} clean_pnm ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@true
@# Nothing to do, .pnm are master coming from xsane
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_jpg) #{
clean_jpg:
@${ECHO_START} "${T_START_RULE} clean_jpg ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_JPG_UCASE} ; do \
rm -f `basename $$i .JPG`.jpg ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_PNG} ; do \
rm -f `basename $$i .png`.jpg ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_PNM} ; do \
rm -f `basename $$i .pnm`.jpg ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_pdf) #{
clean_pdf:
@${ECHO_START} "${T_START_RULE} clean_pdf ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_PDF_UCASE} ; do \
rm -f `basename $$i .PDF`.pdf ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.pdf \
`basename $$i .rof`.[0-9]*.pdf ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.pdf ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.pdf ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.pdf ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIFF} ; do \
rm -f `basename $$i .tiff`.pdf ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TIF} ; do \
rm -f `basename $$i .tif`.pdf ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_PNM} ; do \
rm -f `basename $$i .pnm`.pdf ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_PNG} ; do \
rm -f `basename $$i .png`.pdf ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_PS} ; do \
rm -f `basename $$i .ps`.pdf ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_FIG} ; do \
rm -f `basename $$i .fig`.pdf ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_rof) #{
clean_rof:
@${ECHO_START} "${T_START_RULE} clean_rof ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.rof ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.rof ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_tex) #{
clean_tex:
@${ECHO_START} "${T_START_RULE} clean_tex ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@make clean_dvi
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.tex ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.tex ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_vps) || !target(clean_Vps) #{
# Do not call clean_pcl_rof
clean_vps clean_Vps:
@${ECHO_START} "${T_START_RULE} clean_vps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@make clean_pcl_ps clean_epson clean_cdj670 clean_bjccolor clean_bjc600
@# In case I''ve been editing postscript files eg fax cover sheet
@# (where .ps is the master, not produced from eg a .rof).
@${CMD_FOR_CLEAN} i in ${FOR_PS} ; do \
name=`basename $$i .ps` ; rm -f $${name}.[vV]ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
name=`basename $$i .rof` ; rm -f $${name}.[vV]ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_rof`_$$j.[vV]ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_ROF} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_rof`_$$j.[vV]ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
name=`basename $$i .tex` ; rm -f $${name}.[vV]ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_tex`_$$j.[vV]ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_TEX} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_tex`_$$j.[vV]ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_HTML} ; do \
name=`basename $$i .html` ; rm -f $${name}.[vV]ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_HTML} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_html`_$$j.[vV]ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_HTML} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_html`_$$j.[vV]ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_LMTH} ; do \
name=`basename $$i .lmth` ; rm -f $${name}.[vV]ps ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_lmth`_$$j.[vV]ps ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_lmth`_$$j.[vV]ps ; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_vfig) #{
clean_vfig:
@${ECHO_START} "${T_START_RULE} clean_vfig ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# Clean up after aborted wysiwyg edits of .fig files
@${CMD_FOR_CLEAN} i in ${FOR_FIG} ; do \
rm -f `basename $$i .fig`.vfig ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(clean_vhtml) #{
clean_vhtml:
@${ECHO_START} "${T_START_RULE} clean_vhtml ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# Clean up after aborted wysiwyg edits of .html files
@${CMD_FOR_CLEAN} i in ${FOR_HTML} ; do \
rm -f `basename $$i .html`.vhtml ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_ROF} ; do \
rm -f `basename $$i .rof`.vtml ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_HTML} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_html`_$$j.vhtml ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_HTML} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_html`_$$j.vthml ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_LMTH} ; do \
rm -f `basename $$i .lmth`.vtml ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_E_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .e_lmth`_$$j.vhtml ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_L_LMTH} ; do \
for j in ${LANGS} ; do \
rm -f `basename $$i .l_lmth`_$$j.vhtml ; \
done ; \
done
@${CMD_FOR_CLEAN} i in ${FOR_TEX} ; do \
rm -f `basename $$i .tex`.vtml ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(dvi) #{
dvi:
@${ECHO_START} "${T_START_RULE} dvi ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make rof
${CMD_FOR_BUILD} i in ${FOR_TEX} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tex`.dvi ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(e_html) #{
e_html:
@${ECHO_START} "${T_START_RULE} e_html ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
cd ${.CURDIR} && make l_html
${CMD_FOR_BUILD} i in ${FOR_L_HTML} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
echo "${T_BERKLIX} ${T_PRE_EXIST} $$i" ; \
bla=`basename $$i .l_html` ; \
for j in ${LANGS} ; do \
${ECHO_DOING} "Doing $${bla}_$$j.e_html" ; \
if ! test -e $${bla}_$$j.e_html ; then \
ln -s $$i $${bla}_$$j.e_html ; \
echo "$${bla}_$$j.e_html" ; \
fi; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(e_lmth) #{
e_lmth:
@${ECHO_START} "${T_START_RULE} e_lmth ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make l_lmth
${CMD_FOR_BUILD} i in ${FOR_L_LMTH} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
echo "${T_BERKLIX} ${T_PRE_EXIST} $$i" ; \
bla=`basename $$i .l_lmth` ; \
for j in ${LANGS} ; do \
${ECHO_DOING} "Doing $${bla}_$$j.e_lmth" ; \
if ! test -e $${bla}_$$j.e_lmth ; then \
ln -s $$i $${bla}_$$j.e_lmth ; \
echo "$${bla}_$$j.e_lmth" ; \
fi; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(e_rof) #{
# Create 2 or more sym links for extracting English & German language,
# such as resume_e.e_rof resume_g.e_rof
e_rof:
@${ECHO_START} "${T_START_RULE} e_rof ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make l_rof
${CMD_FOR_BUILD} i in ${FOR_L_ROF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
echo "${T_BERKLIX} ${T_PRE_EXIST} $$i" ; \
bla=`basename $$i .l_rof` ; \
for j in ${LANGS} ; do \
${ECHO_DOING} "Doing $${bla}_$$j.e_rof" ; \
if ! test -e $${bla}_$$j.e_rof ; then \
ln -s $$i $${bla}_$$j.e_rof ; \
echo "$${bla}_$$j.e_rof" ; \
fi; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(e_tex) #{
e_tex:
@${ECHO_START} "${T_START_RULE} e_tex ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make l_tex
${CMD_FOR_BUILD} i in ${FOR_L_TEX} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
echo "${T_BERKLIX} ${T_PRE_EXIST} $$i" ; \
bla=`basename $$i .l_tex` ; \
for j in ${LANGS} ; do \
${ECHO_DOING} "Doing $${bla}_$$j.e_tex" ; \
if ! test -e $${bla}_$$j.e_tex ; then \
ln -s $$i $${bla}_$$j.e_tex ; \
echo "$${bla}_$$j.e_tex" ; \
fi; \
done ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(epson) #{
epson:
@${ECHO_START} "${T_START_RULE} epson ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make rof
${CMD_FOR_BUILD} i in ${FOR_PS} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .ps`.epson ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(html) #{
html:
@${ECHO_START} "${T_START_RULE} html ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# Add functionality to get "make html" go into SUBDIRs
@# /usr/share/mk/bsd.subdir.mk has this:
@# .for __target in all all-man checkdpadd clean cleandepend
@# cleandir \
@# depend distribute lint maninstall \
@# obj objlink realinstall regress tags
@# ${__target}: _SUBDIR
@# .endfor
@# So I do this:
.if defined(SUBDIR)
@# the if defined above is so I dont have to add
@# .include
@# even in public/html/......../Makefile that dont have SUBDIR +=
echo "Next line used to degrade host power on /site/usr/local/www/Data/virtual/berklix.com so commented to just a suggestion"
echo Suggestion: make _SUBDIR
@# JJLATER This goes Recursive: make _SUBDIR
@# JJLATER so for nor I manually do:
@# foreach i ( `find . -type d` )
@# pushd $i
@# ( make html )
@# echo DONE $i
@# popd
@# end
.endif
@# cd ${.CURDIR} is for ~/public_html which sometimes has an obj/
cd ${.CURDIR} && make e_html lmth rof tex
${CMD_FOR_BUILD} i in ${FOR_E_HTML} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
${ECHO_DOING} "Doing $$i" ; \
make `basename $$i .e_html`.html ; \
done
${CMD_FOR_BUILD} i in ${FOR_LMTH} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
${ECHO_DOING} "Doing $$i" ; \
make `basename $$i .lmth`.html ; \
done
${CMD_FOR_BUILD} i in ${FOR_ROF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .rof`.html ; \
done
${CMD_FOR_BUILD} i in ${FOR_TEX} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tex`.html ; \
done
cd ${.CURDIR} && make _index.html
@# ${.CURDIR} above as my ~/public_html also has a /usr/obj equiv.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
# Can not call this target index.html, else it prevents
# index.html being built from index.lmth
.if !target(_index.html) #{
_index.html:
@${ECHO_START} "${T_START_RULE} _index.html ${T_START_TARGET} $@ {"
if [ -e index_e.html ] && [ ! -e index.html ]; then \
echo "${T_BERKLIX} ${T_PRE_EXIST} index_e.html" ; \
ln -s index_e.html index.html ; \
fi
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(l_html) #{
l_html:
@${ECHO_START} "${T_START_RULE} l_html ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# An l_html file is an absolute master, made by human, not machine.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(l_lmth) #{
l_lmth:
@${ECHO_START} "${T_START_RULE} l_lmth ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# An l_lmth file is an absolute master, made by human, not machine.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(l_rof) #{
l_rof:
@${ECHO_START} "${T_START_RULE} l_rof ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# An l_rof file is an absolute master, made by human, not machine.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(l_tex) #{
l_tex:
@${ECHO_START} "${T_START_RULE} l_tex ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# An l_tex file is an absolute master, made by human, not machine.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(lmth) #{
lmth: e_lmth rof tex
@${ECHO_START} "${T_START_RULE} lmth ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
${CMD_FOR_BUILD} i in ${FOR_E_LMTH} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .e_lmth`.lmth ; \
done
${CMD_FOR_BUILD} i in ${FOR_ROF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .rof`.lmth ; \
done
${CMD_FOR_BUILD} i in ${FOR_TEX} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tex`.lmth ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(lmth_links) #{
.if !defined(LMTH_TARGET) #{
LMTH_TARGET_1 != pwd
LMTH_TARGET_2 != basename ${LMTH_TARGET_1}
LMTH_TARGET = ${LMTH_TARGET_2}.lmth
.endif #}
lmth_links:
@${ECHO_START} "${T_START_RULE} lmth_links ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
${CMD_FOR_BUILD} i in ${LMTH_LINKS} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
if test ! -h $$i; then \
echo "${T_BERKLIX} ${T_PRE_EXIST} ${LMTH_TARGET}" ; \
ln -s ${LMTH_TARGET} $$i ; \
else \
echo Link already exists: $$i ; \
fi ; \
ls -l $$i ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(lst) #{
lst:
@${ECHO_START} "${T_START_RULE} lst ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make rof
${CMD_FOR_BUILD} i in ${FOR_ROF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .rof`.lst ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(pcl_rof) #{
pcl_rof:
@${ECHO_START} "${T_START_RULE} pcl_rof ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make rof
${CMD_FOR_BUILD} i in ${FOR_ROF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .rof`.pcl_rof ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(pcl_ps) #{
pcl_ps:
@${ECHO_START} "${T_START_RULE} pcl_ps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make ps
${CMD_FOR_BUILD} i in ${FOR_PS} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .ps`.pcl_ps ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(pcl) #{
pcl:
@${ECHO_START} "${T_START_RULE} pcl ${T_START_TARGET} $@ {"
make ps
@echo "${T_BERKLIX} Suffix PCL no longer exists, you must choose pcl_ps or pcl_rof"
@echo "A .pcl_rof is a .pcl produced direct from a .rof with groff"
@echo "On FreeBSD-8.2 in ~jhs/job/groff/card/paper groff spacing fails."
@echo -n "A .pcl_ps is a .pcl produced from a .rof "
@echo "via a .ps with ghostscript."
@echo "On FreeBSD-8.2 in ~jhs/ob/groff/card/paper/ gs spacing is OK"
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(pdf2ps_maybe) #{
pdf2ps_maybe:
@${ECHO_START} "${T_START_RULE} pdf2ps_maybe ${T_START_TARGET} $@ {"
.if defined(PDF_PS) #{ Default: Undefined.
@echo "${T_BERKLIX} PDF_PS is defined, unusual."
.else
@echo -n "${T_BERKLIX} PDF_PS undefined as normal. "
@echo "You might want it for eg .ps to .pcl"
.endif #}
@# echo "${T_BERKLIX} The echoes above do Not report the truth ${PDF_PS}."
@# make pdf
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(ps) #{
ps:
@${ECHO_START} "${T_START_RULE} ps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make rof tex pdf2ps_maybe fig
${CMD_FOR_BUILD} i in ${FOR_ROF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .rof`.ps ; \
done
${CMD_FOR_BUILD} i in ${FOR_TEX} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tex`.ps ; \
done
${CMD_FOR_BUILD} i in ${FOR_FIG} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .fig`.ps ; \
done
${CMD_FOR_BUILD} i in ${FOR_TIFF2PS} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tiff`.ps ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(eps) #{
eps:
@${ECHO_START} "${T_START_RULE} eps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make fig
${CMD_FOR_BUILD} i in ${FOR_FIG} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .fig`.eps ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(gif) #{
gif:
@${ECHO_START} "${T_START_RULE} gif ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make ps
${CMD_FOR_BUILD} i in ${FOR_PS} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .ps`.gif ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(jpg) #{
jpg:
@${ECHO_START} "${T_START_RULE} jpg ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# make png
.if !defined(TIFF_TO_JPG_FORCE) #{{
${CMD_FOR_BUILD} i in ${FOR_PNG} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5};\
make `basename $$i .png`.jpg ; \
done
@# 2019-01-17 added .pnm
${CMD_FOR_BUILD} i in ${FOR_PNM} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5};\
make `basename $$i .pnm`.jpg ; \
done
.else # }{ # TIFF_TO_JPG_FORCE
${CMD_FOR_BUILD} i in ${FOR_TIFF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5};\
make `basename $$i .tiff`.jpg ; \
done
.endif # }} # TIFF_TO_JPG_FORCE
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(pdf) #{
# 2009.03.02 I deleted dependency .tiff.ps ,
# because .ps output files are enormous
# & I have a .tiff.pdf rule that pipes direct.
# I might need to add rof back in though, else maybe not enough
# will get built ?
pdf:
@# .ps are either imported masters. or created from non .ps masters.
@${ECHO_START} "${T_START_RULE} pdf ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make tex rof fig tiff
@# No ps as I dont edit .ps:
${CMD_FOR_BUILD} i in ${FOR_TEX} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tex`.pdf; \
done
${CMD_FOR_BUILD} i in ${FOR_TIFF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tiff`.pdf ; \
done
${CMD_FOR_BUILD} i in ${FOR_TIF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tif`.pdf; \
done
${CMD_FOR_BUILD} i in ${FOR_FIG} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .fig`.pdf ; \
done
@# There was no .rof.pdf rule,
@# just rules for .rof.ps & a .ps.pdf,
@# so first try to make from a .rof
${CMD_FOR_BUILD} i in ${FOR_ROF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .rof`.pdf; \
done
@# second try to make any .pdf still missing from a .ps
${CMD_FOR_BUILD} i in ${FOR_PS} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .ps`.pdf; \
done
${CMD_FOR_BUILD} i in ${FOR_PDF_UCASE} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .PDF`.pdf ; \
done
${CMD_FOR_BUILD} i in ${FOR_PNG_UCASE} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .PNG`.pdf ; \
done
${CMD_FOR_BUILD} i in ${FOR_PNG} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .png`.pdf ; \
done
${CMD_FOR_BUILD} i in ${FOR_PNM} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .pnm`.pdf ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(png) #{
png:
echo hi
@${ECHO_START} "${T_START_RULE} png ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
${CMD_FOR_BUILD} i in ${FOR_PNG_UCASE} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .PNG`.png ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(pnm) #{
pnm:
echo hi
@${ECHO_START} "${T_START_RULE} pnm ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@echo "Dummy rule in berklix2.mk , normaly .pnm created by xsane"
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(rof) #{
rof:
@${ECHO_START} "${T_START_RULE} rof ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make e_rof
${CMD_FOR_BUILD} i in ${FOR_E_ROF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .e_rof`.rof ; \
done
@${ECHO_END} "${T_END} $@ }"
# Pre 2004.05.14, the single line with `make` was 3 lines:
# for j in ${LANGS} ; do \
# rm -f `basename $$i .e_rof`_$$j.rof ; \
# done ;
.endif #}
#------------------------------------------------------------------------------
.if !target(tiff) #{
tiff:
@${ECHO_START} "${T_START_RULE} tiff ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
.if !defined(PDF_TO_TIFF_FORCE) #{{
${CMD_FOR_BUILD} i in ${FOR_JPG} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .jpg`.tiff ; \
done
${CMD_FOR_BUILD} i in ${FOR_TIF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tif`.tiff ; \
done
.else # }{ # PDF_TO_TIFF_FORCE
@# Code below added 2019-05-14 so I can reverse my A4 PDF in
@# ~/public_html/brexit/posters to tiff, convert to jpg,
@# then create a gallery with cthumb
${CMD_FOR_BUILD} i in ${FOR_PDF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .pdf`.tiff ; \
done
.endif # }} # PDF_TO_TIFF_FORCE
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(fig) #{
fig:
@${ECHO_START} "${T_START_RULE} fig ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
${CMD_FOR_BUILD} i in ${FOR_FIG} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .fig`.pdf ; \
done
@# ${CMD_FOR_BUILD} i in ${FOR_FIG} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
@# make `basename $$i .fig`.ps ; \
@# done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
# bsd.subdir.mk also has a target .txt, with no .if before it.
.if !target(txt) #{
txt:
@${ECHO_START} "${T_START_RULE} txt ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make rof tiff
@# ps # ps is for tex > ps > txt
${CMD_FOR_BUILD} i in ${FOR_ROF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .rof`.txt ; \
done
@# I could add something to ignore warnings such as
@# warning: can''t find font ``H''
${CMD_FOR_BUILD} i in ${FOR_TEX} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tex`.txt ; \
done
@# OCR next
${CMD_FOR_BUILD} i in ${FOR_TIFF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tiff`.txt ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(txt_e) #{
txt_e:
@${ECHO_START} "${T_START_RULE} txt_e ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make tiff
@# rof is not necessary.
@# OCR next
${CMD_FOR_BUILD} i in ${FOR_TIFF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tiff`.txt_e ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(txt_g) #{
txt_g:
@${ECHO_START} "${T_START_RULE} txt_g ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make tiff
@# rof is not necessary.
@# OCR next
${CMD_FOR_BUILD} i in ${FOR_TIFF} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .tiff`.txt_g ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(tex) #{
tex:
@${ECHO_START} "${T_START_RULE} tex ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
make e_tex
${CMD_FOR_BUILD} i in ${FOR_E_TEX} ; do \
${EQUAL1} $$i ${EQUAL2} $$i ${EQUAL3} ${EQUAL4} $$i \
${EQUAL5} ; \
make `basename $$i .e_tex`.tex ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(tools) #{
tools:
@${ECHO_START} "${T_START_RULE} tools ${T_START_TARGET} $@ {"
make ${BUILD_TOOLS} ${VIEW_TOOLS} ${CHECK_TOOLS}
@# You can run "make tools" (as root) to install all tools
@# on a new host, before you later run "make all" as a normal user.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(view) #{
view:
@${ECHO_START} "${T_START_RULE} view ${T_START_TARGET} $@ {"
make ${VIEW_TOOLS}
@echo "${T_BERKLIX} Try one of make view_ps view_pdf view_dvi"
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(view_dvi) #{
view_dvi:
@${ECHO_START} "${T_START_RULE} view_dvi ${T_START_TARGET} $@ {"
# ${XDVI} ${GHOSTVIEW} ${GV} ${GS}
make ${TARGS_DVI}
@${CMD_FOR_CLEAN} i in $(TARGS_PS) ; \
do \
@if [ -x ${XDVI} ]; then \
${XDVI} ${XDVI_ARGS} $$i ; \
elif [ -x ${GHOSTVIEW} ]; then \
${GHOSTVIEW} $$i ; \
elif [ -x ${GV} ]; then \
${GV} $$i ; \
elif [ -x ${GS} ]; then \
${GS} -sPAPERSIZE=a4 $$i ; \
fi ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(view_pdf) #{
view_pdf:
@${ECHO_START} "${T_START_RULE} view_pdf ${T_START_TARGET} $@ {"
make ${TARGS_PDF}
# ${ACROREAD} ${GHOSTVIEW} ${GV} ${GS}
@${CMD_FOR_CLEAN} i in $(TARGS_PS) ; \
do \
@if [ -x ${ACROREAD} ]; then \
${ACROREAD} $$i ; \
elif [ -x ${GHOSTVIEW} ]; then \
${GHOSTVIEW} $$i ; \
elif [ -x ${GV} ]; then \
${GV} $$i ; \
elif [ -x ${GS} ]; then \
${GS} -sPAPERSIZE=a4 $$i ; \
fi ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(view_ps) #{
view_ps:
# ${GV} ${GHOSTVIEW} ${GS}
@${ECHO_START} "${T_START_RULE} view_ps ${T_START_TARGET} $@ {"
make ${TARGS_PS}
@${CMD_FOR_CLEAN} i in $(TARGS_PS) ; \
do \
@if [ -x ${GV} ]; then \
${GV} -media a4 -antialias $$i ; \
elif [ -x ${GHOSTVIEW} ]; then \
${GHOSTVIEW} $$i.ps; \
elif [ -x ${GS} ]; then \
${GS} -sPAPERSIZE=a4 $$i.ps; \
fi ; \
done
@${ECHO_END} "${T_END} $@ }"
.endif #}
#==============================================================================
.if !target(.rof.pdf) #{
# The rules for .rof.ps & .ps.pdf were sufficient to make a .pdf
# but I added this rule, as using just the earlier 2 rules left bulky .ps files
# that were surplus bulk on web directories, in ~/ at home, & on USB sticks,
# & slowed rdist back ups, & bad for wear on USB flash media.
.rof.pdf:
@${ECHO_START} "${T_START_RULE} .rof.pdf ${T_START_TARGET} $@ {"
${GROFF} -Tps -dformat=ps \
-dfile=`basename ${.TARGET} .ps` ${.IMPSRC} \
| ${PS2PDF} -sPAPERSIZE=a4 - ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.dvi.pdf) #{
# The rules for .dvi.ps & .ps.pdf were sufficient to make a .pdf
# but I added this rule, as using just the earlier 2 rules left bulky .ps files
# that were surplus bulk on web directories, in ~/ at home, & on USB sticks,
# & slowed rdist back ups, & bad for wear on USB flash media.
# For explanation of parameters see comments in rule .dvi.ps
.dvi.pdf:
@${ECHO_START} "${T_START_RULE} .dvi.pdf ${T_START_TARGET} $@ {"
@make ${DVIPS} ${PSSELECT} ${PSNUP} ${PSTOPS} ${PS2PDF}
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
dvips -t landscape -o tmp.`basename ${.TARGET} .pdf`.ps ${.IMPSRC}
psselect 2,3,4,5,6,1 tmp.`basename ${.TARGET} .pdf`.ps \
tmp2.`basename ${.TARGET} .pdf`.ps
$(PSNUP) -w21cm -h29.2cm -W9.9cm -H21cm -s1 -3 \
tmp2.`basename ${.TARGET} .pdf`.ps \
`basename ${.TARGET} .pdf`.ps
rm -f tmp.`basename ${.TARGET} .pdf`.ps \
tmp2.`basename ${.TARGET} .pdf`.ps
cat `basename ${.TARGET} .pdf`.ps \
| ${PS2PDF} -sPAPERSIZE=a4 - ${.TARGET}
rm `basename ${.TARGET} .pdf`.ps
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
# DEFAULT INPUT-OUTPUT CONVERSION RULES - WYSIWYG
#------------------------------------------------------------------------------
sighup=HUP
# Support for "ghostview".
# (ghostview is marked broken (security loophone) in FreeBSD-4.8)
# Wysiwyg loop to allow vi in one xterm to cause re-display in adjacent
# ghostview, each time vi sees :w (write).
.if !target(.ps.vps) #{
.ps.vps: # create a temporary pid file for signal linking vi + ghostview
@${ECHO_START} "${T_START_RULE} .ps.vps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# echo "${T_BERKLIX} ghostview gone in current 2014-12-26, need to port my mods to gv"
@sleep 2
ghostview -reopen_sig -pid_report ${.IMPSRC} > ${.TARGET} &
@# Wait for ghostview to initialise then report its process number.
@# & print dots while waiting as a debug indicator.
@# while `test ! -s ${.TARGET}` ; do echo -n . ; done
@# or skip the dots normally.
while `test ! -s ${.TARGET}` ; do true ; done
process=`cat ${.TARGET}` ; \
name=`basename ${.IMPSRC} .ps` ; \
if [ -f $${name}.le ]; then \
vi -C "make $${name}.ps ; kill -${SIG_REOPEN} $${process}" \
$${name}.le ; \
else \
if [ -f $${name}.e_rof ]; then \
vi -C "make $${name}.ps ; \
kill -${SIG_REOPEN} $${process}" \
${.CURDIR}/$${name}.e_rof ; \
elif [ -f $${name}.rof ]; then \
vi -C "make $${name}.ps ; \
kill -${SIG_REOPEN} $${process}" \
${.CURDIR}/$${name}.rof ; \
elif [ -f $${name}.e_tex ]; then \
vi -C "make $${name}.ps ; \
kill -${SIG_REOPEN} $${process}" \
${.CURDIR}/$${name}.e_tex ; \
elif [ -f $${name}.tex ]; then \
vi -C "make $${name}.ps ; \
kill -${SIG_REOPEN} $${process}" \
${.CURDIR}/$${name}.tex ; \
else \
echo "${T_BERKLIX} Dont know what to edit to make $${name}" ; \
exit 1 ; \
fi ; \
fi ; \
kill -${sighup} $${process} ; \
echo "${T_BERKLIX} Suggestion: maybe_rm $${name}.ps"
# letter_g.rof is extracted from letter_g.e_rof
# letter_g.e_rof@ -> letter.l_rof
# {--------------- OLD
# if [ -f $${name}.le ]; then \
# vi -C "make $${name}.ps ; kill -${SIG_REOPEN} $${process}" \
# $${name}.le ; \
# else \
# if [ -f $${name}.rof ]; then \
# vi -C "make $${name}.ps ; \
# kill -${SIG_REOPEN} $${process}" \
# ${.CURDIR}/$${name}.rof ; \
# else \
# vi -C "make $${name}.ps ; \
# kill -${SIG_REOPEN} $${process}" \
# ${.CURDIR}/$${name}.tex ; \
# fi ; \
# fi ; \
# kill -${sighup} $${process} ; \
# echo "${T_BERKLIX} Suggestion: maybe_rm $${name}.ps"
# --------------- }
@# JJLATER: Allow for a $${name}.tex as well as a $${name}.rof
@rm -f ${.TARGET}
@# merely an obsolete process number
@#
@# The ${sighup} is to remove a no longer updated ghostview.
@#
@# Hopefully a kernel guru will confirm the printf & fflush I use to
@# generate the pid print in ghostview is effectively monatomic by the
@# time the process number arrives in the file ${THING}.pid.
@# If not, and the pid were eg 1234,
@# & only the 1 is output before the test,
@# and it stays at 1 when then read with cat, and if you are root,
@# the system might then crash or something with equivalent of
@# su ; kill -SIGUSR1 1 (note SIGUSR1)
@#
@# Note ghostview sometimes doesnt seem to update its screen display
@# till the mouse floats over the top of it (no clicks necessary)
@# (this being with fvwm + freebsd).
@#
@# I couldn''t use a structure like
@# pid=`ghostview -reopen_sig -pid_report generic.g.ps` &
@# because that waits for ghostview to complete before evaluating pid
@#
@# The backslashes need to extend to end, else $${name} evaluate
@# to null on the suggestion line.
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
# Support for "gv". (successor or descendant to/from ghostview).
# Wysiwyg loop to allow vi in one xterm to cause re-display in adjacent
# gv, each time vi sees :w (write).
.if !target(.ps.Vps) #{
.ps.Vps: # create a temporary pid file for signal linking vi + ghostview
@${ECHO_START} "${T_START_RULE} .ps.Vps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# A "-watch" parameter to gv is not needed, & avoided to lighten load
@# on slow machines.
${GV} ${.IMPSRC} > ${.TARGET} & \
sleep 3 ; \
process=$$! ; \
echo "$${process}" > ${.TARGET} ; \
name=`basename ${.IMPSRC} .ps` ; \
if [ -f $${name}.le ]; then \
vi -C "make $${name}.ps ; kill -s HUP $${process}" \
$${name}.le ; \
else \
if [ -f $${name}.rof ]; then \
vi -C "make $${name}.ps ; kill -s HUP $${process}" \
${.CURDIR}/$${name}.rof ; \
else \
vi -C "make $${name}.ps ; kill -s HUP $${process}" \
${.CURDIR}/$${name}.tex ; \
fi ; \
fi ; \
kill $${process} ; \
echo "${T_BERKLIX} Suggestion: maybe_rm $${name}.ps"
@# JJLATER: Allow for a $${name}.tex as well as a $${name}.rof
@rm -f ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
# Same as .ps.vps, but also generates a .pcl_rof afterward
# (note no .vpcl_rof gets generated).
.if !target(.rof.vpcl_rof) #{
.rof.vpcl_rof:
@${ECHO_START} "${T_START_RULE} .rof.vpcl_rof ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
name=`basename ${.IMPSRC} .rof` ; \
make $${name}.vps ; \
tm $${name}.ps ; \
make $${name}.pcl_rof ; \
echo Suggestion: lpr -Ppcl_rof.g $${name}.pcl_rof
@${ECHO_END} "${T_END} $@ }"
@# The Wysiwyg uses the .ps,
@# then we discard the .ps, & go straight from rof to pcl.
.endif #}
#------------------------------------------------------------------------------
# Same as .ps.vps, but also generates a .pcl_ps afterward
# (note no .vpcl_ps gets generated).
.if !target(.ps.vpcl_ps) #{
.ps.vpcl_ps:
@${ECHO_START} "${T_START_RULE} .ps.vpcl_ps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
name=`basename ${.IMPSRC} .ps` ; \
make $${name}.vps ; \
make $${name}.pcl_ps ; \
echo Suggestion: lpr -Ppcl_ps.g $${name}.pcl_ps
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.ps.vbjccolor) #{
# (note no .vbjccolor gets generated).
.ps.vbjccolor:
@${ECHO_START} "${T_START_RULE} .ps.vbjccolor ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
name=`basename ${.IMPSRC} .ps` ; \
make $${name}.vps ; \
make $${name}.bjccolor ; \
echo Suggestion: lpr -Pbjc $${name}.bjccolor
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.ps.vcdj670) #{
# (note no .vcdj670 gets generated).
.ps.vcdj670:
@${ECHO_START} "${T_START_RULE} .ps.vcdj670 ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
name=`basename ${.IMPSRC} .ps` ; \
make $${name}.vps ; \
make $${name}.cdj670 ; \
echo Suggestion: lpr -Pcdj670 $${name}.cdj670
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.ps.vbjc600) #{
.ps.vbjc600:
@${ECHO_START} "${T_START_RULE} .ps.vbjc600 ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
name=`basename ${.IMPSRC} .ps` ; \
make $${name}.vps ; \
make $${name}.bjc600 ; \
echo Suggestion: lpr -Pbjc $${name}.bjc600
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
CHIMERA_PARAMS = -s -p
# CHIMERA_PARAMS are not available from generic chimera, but are added by:
# http://berklix.com/~jhs/src/bsd/fixes/FreeBSD/ports/gen/www/chimera/files/
# JJLATER: Warning chimera has disappeared by 2016-04-14 from ports/www/
.if !target(.m4.vhtml) #{
# This new rule is being tested first on ~/public_html/bim/Makefile
# There is not yet a generic clean rule. That comes from the Makefile for now.
.m4.vhtml: # create a temporary pid file for signal linking vi + chimera
@${ECHO_START} "${T_START_RULE} .m4.vhtml ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# for explanation see comments in .ps.vps: above
@# I need ${.CURDIR} in next line, else chimera fails to display
@# ~jhs/public_html/ (as /usr/obj/.... always exists)
make `basename ${.IMPSRC} .m4`.html
chimera ${CHIMERA_PARAMS} ${.CURDIR}/`basename ${.IMPSRC} .m4`.html > ${.TARGET} &
@# Wait for chimera to initialise then report its process number.
@# & print dots while waiting as a debug indicator.
@# while `test ! -s ${.TARGET}` ; do echo -n . ; done
@# or skip the dots normally.
while `test ! -s ${.TARGET}` ; do true ; done
process=`cat ${.TARGET}` ; \
name=`basename ${.IMPSRC} .m4` ; \
vi -C "make $${name}.html ; kill -${SIG_REOPEN} $${process}" \
${.CURDIR}/$${name}.m4 ; \
${SPELLAFTERVI} ${.CURDIR}/$${name}.m4 ; \
${TIDYAFTERVI} ${.CURDIR}/$${name}.m4 ; \
${CHECKLINKSAFTERVI} ${.CURDIR}/$${name}.m4 ; \
kill -${sighup} $${process}
rm -f ${.TARGET}
@# Do a 2nd tidy to see if there were any unfixable errors.
echo "Consider something like ${TIDY} ${.IMPSRC} > /dev/null"
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.html.vhtml) #{
.html.vhtml: # create a temporary pid file for signal linking vi + chimera
@${ECHO_START} "${T_START_RULE} .html.vhtml ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# for explanation see comments in .ps.vps: above
@# I need ${.CURDIR} in next line, else chimera fails to display
@# ~jhs/public_html/ (as /usr/obj/.... always exists)
chimera ${CHIMERA_PARAMS} ${.CURDIR}/${.IMPSRC} > ${.TARGET} &
@# Wait for chimera to initialise then report its process number.
@# & print dots while waiting as a debug indicator.
@# while `test ! -s ${.TARGET}` ; do echo -n . ; done
@# or skip the dots normally.
while `test ! -s ${.TARGET}` ; do true ; done
process=`cat ${.TARGET}` ; \
name=`basename ${.IMPSRC} .html` ; \
vi -C "make $${name}.html ; kill -${SIG_REOPEN} $${process}" \
${.CURDIR}/$${name}.html ; \
${SPELLAFTERVI} ${.CURDIR}/$${name}.html ; \
${TIDYAFTERVI} ${.CURDIR}/$${name}.html ; \
${CHECKLINKSAFTERVI} ${.CURDIR}/$${name}.html ; \
kill -${sighup} $${process}
rm -f ${.TARGET}
@# Do a 2nd tidy to see if there were any unfixable errors.
-${TIDY} ${.IMPSRC} > /dev/null
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.lmth.vhtml) #{
.lmth.vhtml: # create a temporary pid file for signal linking vi + chimera
@${ECHO_START} "${T_START_RULE} .lmth.vhtml ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# for explanation see comments in .ps.vps: above
@# I need ${.CURDIR} in next line, else chimera fails to display
@# ~jhs/public_html/ (as /usr/obj/.... always exists)
cd ${.CURDIR} ; make `basename ${.IMPSRC} .lmth`.html
chimera ${CHIMERA_PARAMS} ${.CURDIR}/`basename ${.IMPSRC} .lmth`.html > \
${.TARGET} &
@# Wait for chimera to initialise then report its process number.
@# & print dots while waiting as a debug indicator.
@# while `test ! -s ${.TARGET}` ; do echo -n . ; done
@# or skip the dots normally.
while `test ! -s ${.TARGET}` ; do true ; done
process=`cat ${.TARGET}` ; \
name=`basename ${.IMPSRC} .lmth` ; \
vi -C "make $${name}.html ; kill -${SIG_REOPEN} $${process}" \
${.CURDIR}/$${name}.lmth ; \
${SPELLAFTERVI} ${.CURDIR}/$${name}.lmth ; \
${TIDYAFTERVI} ${.CURDIR}/$${name}.lmth ; \
${CHECKLINKSAFTERVI} ${.CURDIR}/$${name}.lmth ; \
kill -${sighup} $${process}
rm -f ${.TARGET}
@# Do a 2nd tidy to see if there were any unfixable errors.
-${TIDY} ${.IMPSRC} > /dev/null
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.e_lmth.vhtml) #{
.e_lmth.vhtml: # create a temporary pid file for signal linking vi + chimera
@${ECHO_START} "${T_START_RULE} .e_lmth.vhtml ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# for explanation see comments in .ps.vps: above
@# I need ${.CURDIR} in next line, else chimera fails to display
@# ~jhs/public_html/ (as /usr/obj/.... always exists)
make `basename ${.IMPSRC} .e_lmth`.html
chimera ${CHIMERA_PARAMS} ${.CURDIR}/`basename ${.IMPSRC} .e_lmth`.html \
> ${.TARGET} &
@# Wait for chimera to initialise then report its process number.
@# & print dots while waiting as a debug indicator.
@# while `test ! -s ${.TARGET}` ; do echo -n . ; done
@# or skip the dots normally.
while `test ! -s ${.TARGET}` ; do true ; done
process=`cat ${.TARGET}` ; \
name=`basename ${.IMPSRC} .e_lmth` ; \
vi -C "make $${name}.html ; kill -${SIG_REOPEN} $${process}" \
${.CURDIR}/$${name}.e_lmth ; \
kill -${sighup} $${process}
rm -f ${.TARGET}
@# Do a 2nd tidy to see if there were any unfixable errors.
-${TIDY} ${.IMPSRC} > /dev/null
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.fig.vfig) #{
.fig.vfig: # create a temporary pid file for signal linking vi + xfig
@${ECHO_START} "${T_START_RULE} .fig.vfig ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# for explanation see comments in .ps.vps: above
xfig -pid_report -reopen_sig ${.IMPSRC} > ${.TARGET} &
@# Wait for xfig to initialise then report its process number.
@# & print dots while waiting as a debug indicator.
@# while `test ! -s ${.TARGET}` ; do echo -n . ; done
@# or skip the dots normally.
while `test ! -s ${.TARGET}` ; do true ; done
process=`cat ${.TARGET}` ; \
name=`basename ${.IMPSRC} .fig` ; \
vi -C "make $${name}.fig ; kill -${SIG_REOPEN} $${process}" \
${.CURDIR}/$${name}.fig ; \
kill -SIGKILL $${process}
rm -f ${.TARGET}
@# Xfig with a ${sighup} creates a core, (despite man signal saying
@# default is no core), so as xfig does this I use sigkill
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
PSTOPNM_ARGS += `printenv PSTOPNM_ARGS`
#------------------------------------------------------------------------------
GROFF_ARGS += `printenv GROFF_ARGS`
.if defined(phone) #{
# GROFF_ARGS += -dphone="${phone}"
# Avoid make breaking on double quotes then unprotected space chars in
# ~/job/project/cd/labels/4.4-RELEASE
GROFF_ARGS += -dphone=${phone}
.endif #}
.if defined(phone_web) #{
GROFF_ARGS += -dphone_web="${phone_web}"
.endif #}
.if defined(mobile) #{
GROFF_ARGS += -dmobile="${mobile}"
.endif #}
.if defined(mobile_de) #{
GROFF_ARGS += -dmobile_de="${mobile_de}"
.endif #}
.if defined(mobile_uk) #{
GROFF_ARGS += -dmobile_uk="${mobile_uk}"
.endif #}
.if defined(fax) #{
GROFF_ARGS += -dfax="${fax}"
.endif #}
.if defined(email_b) #{
GROFF_ARGS += -demail_b="${email_b}"
.endif #}
.if defined(email_p) #{
GROFF_ARGS += -demail_p="${email_p}"
.endif #}
.if defined(email_pc) #{
GROFF_ARGS += -demail_pc="${email_pc}"
.endif #}
.if defined(email_bc) #{
GROFF_ARGS += -demail_bc="${email_bc}"
.endif #}
.if defined(email) #{
GROFF_ARGS += -demail="${email}"
.endif #}
.if defined(web_b) #{
GROFF_ARGS += -dweb_b="${web_b}"
.endif #}
.if defined(web_p) #{
GROFF_ARGS += -dweb_p="${web_p}"
.endif #}
.if defined(web) #{
GROFF_ARGS += -dweb="${web}"
.endif #}
.if defined(bank_name) #{
GROFF_ARGS += -dbank_name="${bank_name}"
.endif #}
.if defined(bank_head) #{
GROFF_ARGS += -dbank_head="${bank_head}"
.endif #}
.if defined(bank_branch) #{
GROFF_ARGS += -dbank_branch="${bank_branch}"
.endif #}
.if defined(bank_sort) #{
GROFF_ARGS += -dbank_sort="${bank_sort}"
.endif #}
.if defined(bank_account_number) #{
GROFF_ARGS += -dbank_account_number="${bank_account_number}"
.endif #}
.if defined(bank_account_name) #{
GROFF_ARGS += -dbank_account_name="${bank_account_name}"
.endif #}
.if defined(bank_iban) #{
GROFF_ARGS += -dbank_iban="${bank_iban}"
.endif #}
.if defined(bank_bic) #{
GROFF_ARGS += -dbank_bic="${bank_bic}"
.endif #}
.if defined(address) #{
GROFF_ARGS += -daddress="${address}"
.endif #}
.if defined(street) #{
GROFF_ARGS += -dstreet="${street}"
.endif #}
.if defined(str) #{
GROFF_ARGS += -dstr="${str}"
.endif #}
.if defined(postcode) #{
GROFF_ARGS += -dpostcode="${postcode}"
.endif #}
.if defined(city_postcode) #{
GROFF_ARGS += -dcity_postcode="${city_postcode}"
.endif #}
.if defined(city_short_nat) #{
GROFF_ARGS += -dcity_short_nat="${city_short_nat}"
.endif #}
.if defined(city_short_int) #{
GROFF_ARGS += -dcity_short_int="${city_short_int}"
.endif #}
.if defined(city_short) #{
GROFF_ARGS += -dcity_short="${city_short}"
.endif #}
.if defined(city_long_nat) #{
GROFF_ARGS += -dcity_long_nat="${city_long_nat}"
.endif #}
.if defined(city_long_int) #{
GROFF_ARGS += -dcity_long_int="${city_long_int}"
.endif #}
.if defined(city_long) #{
GROFF_ARGS += -dcity_long="${city_long}"
.endif #}
.if defined(city) #{
GROFF_ARGS += -dcity="${city}"
.endif #}
.if defined(county_short_nat) #{
GROFF_ARGS += -dcounty_short_nat="${county_short_nat}"
.endif #}
.if defined(county_short_int) #{
GROFF_ARGS += -dcounty_short_int="${county_short_int}"
.endif #}
.if defined(county_short) #{
GROFF_ARGS += -dcounty_short="${county_short}"
.endif #}
.if defined(county_long_nat) #{
GROFF_ARGS += -dcounty_long_nat="${county_long_nat}"
.endif #}
.if defined(county_long_int) #{
GROFF_ARGS += -dcounty_long_int="${county_long_int}"
.endif #}
.if defined(county_long) #{
GROFF_ARGS += -dcounty_long="${county_long}"
.endif #}
.if defined(county) #{
GROFF_ARGS += -dcounty="${county}"
.endif #}
.if defined(country_short_nat) #{
GROFF_ARGS += -dcountry_short_nat="${country_short_nat}"
.endif #}
.if defined(country_short_int) #{
GROFF_ARGS += -dcountry_short_int="${country_short_int}"
.endif #}
.if defined(country_short) #{
GROFF_ARGS += -dcountry_short="${country_short}"
.endif #}
.if defined(country_long_nat) #{
GROFF_ARGS += -dcountry_long_nat="${country_long_nat}"
.endif #}
.if defined(country_long_int) #{
GROFF_ARGS += -dcountry_long_int="${country_long_int}"
.endif #}
.if defined(country_long) #{
GROFF_ARGS += -dcountry_long="${country_long}"
.endif #}
.if defined(country) #{
GROFF_ARGS += -dcountry="${country}"
.endif #}
.if defined(language) #{
GROFF_ARGS += -dcountry="${language}"
.endif #}
# place: "munich"|"aachen"|"twells"
# set by .ds in a .rof letter, used as switch
.if defined(place) #{
GROFF_ARGS += -dplace="${place}"
.endif #}
GROFF_EXE = groff
# /usr/bin/groff
# /usr/local/bin/groff
GROFF = ${GROFF_EXE} -U -b -s -t ${GROFF_ARGS}
# GROFF is also used in ~/job/cover/cv/Makefile,
# dont change or remove it.
# -b gives a backtrace ie more debug info if errors occur
# -t in GROFF is for if I''m including tbl boxes in cv_complete.l_rof
# -U for "unsafe mode"
# Version from groff -v
# FreeBSD-8.2-RELEASE 1.19.2
# FreeBSD-8.3-RELEASE 1.19.2
# FreeBSD-8.3-RELEASE /usr/ports/textproc/groff 1.21
# # http://www.gnu.org/software/groff/
#------------------------------------------------------------------------------
# man gs:
# The "-sDEVICE=" switch must precede the first mention of a file to
# print.
# gs5.10/use.txt line 169:
# Individual documents also can (and often do) specify a paper size,
# which will take precedence over the default one. If you want to force
# a specific paper size, ignoring the paper size specified in the
# document, make that paper size the default (as just described),
# and also include -dFIXEDMEDIA.
.if ! defined(GS_ARGS) #{
GS_ARGS = -sPAPERSIZE=a4 -dFIXEDMEDIA -dNOPAUSE -q
.endif #}
# For a basic HP3P with no extension ram (beyond 1M basic) you need to use
# 150 dpi instead of default 300 dpi.
# GS_ARGS += -r150x150
# -dSAFER: Disables deletefile and renamefile operators
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
.if !defined(GS_OUT)
#{
GS_OUT = -sOutputFile=${.TARGET}
# -sOutputFile=page.%02d.${.TARGET}
.endif #}
#------------------------------------------------------------------------------
.if !defined(COPY_IT) #{
# Note below $< & ${.IMPSRC} dont work.
# Used for copying pre built .ps .pcl etc from private directory to public web.
# ---
# With a rule in a public_html/ sub directory Makefile this:
# stadtmuenchen.g.bjc: ${WEB}/stadtmuenchen.g.bjc
# @# ${COPY_IT}
# The variables expand as follows:
# ${.ALLSRC} /.amd_mnt/user/home/jhs/public_html/stadtmuenchen/../../\
# job/groff/letter/stadtmuenchen/web/stadtmuenchen.g.bjc \
# stadtmuenchen.g.ps
# ${.IMPSRC} stadtmuenchen.g.ps
# ${.OODATE} /.amd_mnt/user/home/jhs/public_html/stadtmuenchen/../..\
# /job/groff/letter/stadtmuenchen/web/stadtmuenchen.g.bjc \
# stadtmuenchen.g.ps
# ${.PREFIX} stadtmuenchen.g
# ${.TARGET} stadtmuenchen.g.bjc
# $< stadtmuenchen.g.ps
# So this rule fails:
# COPY_IT = install -c -m 644 ${.ALLSRC} ${.TARGET}
# COPY = install -c -m 644 ${SRCD}/${.TARGET} ${.TARGET}
# I switched from install -c to install -C to save web upload time etc.
COPY = install -C -m 644 ${SRCD}/${.TARGET} ${.TARGET}
# Since ~jhs/public_html/gifs/card/Makefile has not one ${SRCD} but 3.
# COPY does not work, so use COPY2
#-------
# COPY2 = echo ALLSRC ${.ALLSRC} IMPSRC ${.IMPSRC} \
# OODATE ${.OODATE} PREFIX ${.PREFIX} TARGET ${.TARGET} zzz
#-------
COPY2 = install -C -m 644 ${.ALLSRC} ${.TARGET}
.endif #}
#------------------------------------------------------------------------------
# Umlauts Usage
# \*(:a \*(:o \*(:u \*(:s \*(:A \*(:O \*(:U )))))))
# \*[:a] \*[:o] \*[:u] \*[:s] \*[:A] \*[:O] \*[:U]
# M\*[:u]nchnerstra\*(:se )
#------------------------------------------------------------------------------
# DEFAULT INPUT-OUTPUT CONVERSION RULES - NORMAL DATA, NOT WYSIWYG
# Alphabetic order
#------------------------------------------------------------------------------
.if !target(.txt.dos) #{
.txt.dos: # ascii to dos
@${ECHO_START} "${T_START_RULE} .txt.dos ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
cp ${.IMPSRC} ${.TARGET}
${NOTAIL} ${.TARGET}
addcr ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.dvi.ps) #{
# Specific to the BIM3 column leaflet, for now.
.dvi.ps:
@${ECHO_START} "${T_START_RULE} .dvi.ps ${T_START_TARGET} $@ {"
@make ${DVIPS} ${PSSELECT} ${PSNUP} ${PSTOPS}
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# This rule is only good for producing a 3 column leaflet,
@# it is Not a general rule.
@# -----
@# Man dvips - convert a TeX DVI file to PostScript
dvips -t landscape -o tmp.${.TARGET} ${.IMPSRC}
@# Allowable syntax:
@# -t a4
@# -O .1in,-.3cm # Off from default 1" down 1" right.
@# -T offset # Set paper size to given pair of dimensions.
@# -----
@# The previous latex delivers front page last, which suits us.
@# Without the psselect, fold both edges into the middle,
@# & the last page is visible when folded, which is nice, as
@# the English version has additional URLs exposed on back.
@# Man psselect - select pages from a PostScript file
psselect 2,3,4,5,6,1 tmp.${.TARGET} tmp2.${.TARGET}
@# -----
@# Man psnup - multiple pages per sheet
$(PSNUP) -w21cm -h29.2cm -W9.9cm -H21cm -s1 -3 \
tmp2.${.TARGET} ${.TARGET}
@# 29.7 to 29.2 as Brother HL-P2500 was off the short edge.
@# A4 measured by JHS is 29.7 x 21 cm. 9.9 is column width
@# -W -H input sizes, if different from the output sizes.
@# -w -h output sizes.
@# Allowable syntax:
@# -Pa4 # default is a4. -Pletter
@# -m0.3cm # man says: leave margin around the whole page
@# # only really seems to displace from left & base
@# # margin, overflowing off not top & right.
@# -----
@# Man pstops - shuffle pages in a PostScript file
@# Allowable syntax:
@# -pa4
@# $(PSTOPS) -w21cm -h29.7cm "$(PSTOPS_ARGS)" tmp.${.TARGET} ${.TARGET}
@# Always screws up & prints 2nd page upside down.
@# -----
rm -f tmp.${.TARGET} tmp2.${.TARGET}
@# -----
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.e_html.html) #{
# _LANG_HTML extracts the e from foobar_e.html or the g from foobar_g.html
_LANG_HTML = `basename ${.IMPSRC} .e_html | rev |awk 'BEGIN {FS="_"} {print $$1}'`
.e_html.html:
@${ECHO_START} "${T_START_RULE} .e_html.html ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
echo "" > ${.TARGET}
${LE} -${_LANG_HTML} ${.IMPSRC} >> ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.e_lmth.lmth) #{
# _LANG_LMTH extracts the e from foobar_e.lmth or the g from foobar_g.lmth
_LANG_LMTH = `basename ${.IMPSRC} .e_lmth | rev |awk 'BEGIN {FS="_"} {print $$1}'`
.e_lmth.lmth:
@${ECHO_START} "${T_START_RULE} .e_lmth.lmth ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
echo "" > ${.TARGET}
${LE} -${_LANG_LMTH} ${.IMPSRC} >> ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.e_rof.rof) #{
# _LANG_ROF extracts the e from foobar_e.rof or the g from foobar_g.rof
_LANG_ROF = `basename ${.IMPSRC} .e_rof | rev |awk 'BEGIN {FS="_"} {print $$1}'`
.e_rof.rof:
@${ECHO_START} "${T_START_RULE} .e_rof.rof ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# "\\\" " "
echo ".\\\" ${DONT_EDIT}" > ${.TARGET} # "
${LE} -${_LANG_ROF} ${.IMPSRC} >> ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.e_tex.tex) #{
# _LANG_TEX extracts the e from foobar_e.tex or the g from foobar_g.tex
# (${LATEX2HTML} refuses double dotted names such as doc.english.tex)
_LANG_TEX = `basename ${.IMPSRC} .e_tex | rev |awk 'BEGIN {FS="_"} {print $$1}'`
.e_tex.tex:
@${ECHO_START} "${T_START_RULE} .e_tex.tex ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
echo "% ${DONT_EDIT}" > ${.TARGET}
${LE} -${_LANG_TEX} ${.IMPSRC} >> ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.fax.ps) #{
# convert received fax to postscript ready for ghostview
.fax.ps:
@${ECHO_START} "${T_START_RULE} .fax.ps ${T_START_TARGET} $@ {"
@make ${FAX2PS}
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
${FAX2PS} ${.IMPSRC} > ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.fig.ps) #{
.fig.ps:
@${ECHO_START} "${T_START_RULE} .fig.ps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# ${FIG2DEV} -L ps -P -z A4 ${.IMPSRC} > ${.TARGET}
@# FreeBSD-9.2 does not support ${FIG2DEV} -P
@# FreeBSD-10.0 man ${FIG2DEV}:
@# -P Generate a complete LaTeX file. In other words,
@# the output file can be formatted without requiring any
@# changes. The additional text inserted in the beginning
@# and at the end of the file is controlled by the configuration
@# parameter "Preamble" and "Post- amble".
@# So 2014_09_09 I removed -P
${FIG2DEV} -L ps -z A4 ${.IMPSRC} > ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
# Till 2016-02-02 theer was no .fig.ps rule, so it went through
# .fig.ps & .ps.pdf which produced surplus .ps files.
.if !target(.fig.ps) #{
.fig.pdf:
@${ECHO_START} "${T_START_RULE} .fig.pdf ${T_START_TARGET} $@ {"
@make ${FIG2DEV} ${PS2PDF}
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# see comments in .fig.ps
${FIG2DEV} -L ps -z A4 ${.IMPSRC} | \
${PS2PDF} ${PS2PDF_LAND_ARGS} - ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.fig.eps) #{
.fig.eps:
@${ECHO_START} "${T_START_RULE} .fig.eps ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
@# ${FIG2DEV} -L ps -P -z A4 ${.IMPSRC} > ${.TARGET}
@# FreeBSD-9.2 does not support ${FIG2DEV} -P
@# FreeBSD-10.0 man ${FIG2DEV}:
@# -P Generate a complete LaTeX file. In other words,
@# the output file can be formatted without requiring any
@# changes. The additional text inserted in the beginning
@# and at the end of the file is controlled by the configuration
@# parameter "Preamble" and "Post- amble".
@# So 2014_09_09 I removed -P
${FIG2DEV} -L ps -z A4 ${.IMPSRC} > ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.ps.epsi) #{
.ps.epsi:
@${ECHO_START} "${T_START_RULE} .ps.epsi ${T_START_TARGET} $@ {"
@${ECHO_BUILD} "${.TARGET}: ${.IMPSRC}"
${PS2EPSI} ${.IMPSRC} ${.TARGET}
@${ECHO_END} "${T_END} $@ }"
.endif #}
#------------------------------------------------------------------------------
.if !target(.lmth.html) #{
NO_OBJ=true
# Append a standard ${LMTH_TAIL} footer to a .lmth file, to make a .html.
.if !defined(LMTH_TAIL) #{
.if defined(NO_SIDEBAR) #{
LMTH_TAIL = ${.CURDIR}/Inc/tail_no_sb.inc
.else # }{
.if exists( ${.CURDIR}/.just_com ) #{
LMTH_TAIL = ${.CURDIR}/Inc/tail_sb_com.inc
.else # }{
LMTH_TAIL = ${.CURDIR}/Inc/tail_sb_org.inc
.endif #}
.endif #}
.endif #}
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# The files .just_com used to be zero size file until 2017-06-20,
# when I inserted in each: used by berklix2.mk to silence errors from
# httrack --spider -p0 -P gate:80 --verbose berklix.com/jhs
# which complained eg:
# file not stored in cache due to bogus state
# (incomplete type with OK (200), size 0):
# localhost/~jhs/some_dir/.just_com
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
.if !defined(SP_TOP) #{
.if exists( ${.CURDIR}/.just_com ) #{
SP_TOP = ${.CURDIR}/Inc/sidebar_com.sed
.else # }{
SP_TOP = ${.CURDIR}/Inc/sidebar_org.sed
.endif #}
.endif #}
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
.lmth.html: ${LMTH_TAIL} ${SP_TOP}
@${ECHO_START} "${T_START_RULE} .lmth.html ${T_START_TARGET} $@ {"
@# echo "${T_BERKLIX} DEBUG CURDIR: ${.CURDIR}"
@# localhost: /0s1/usr1/home/jhs/._dir/public_html/src
@# amd+nfs_host:
@# /.amd_mnt/scrn/0s1/usr1/home/jhs/._dir/public_html/src
@# echo "${T_BERKLIX} DEBUG TARGET: ${.TARGET}"
@# localhost:
@# fixes.html
@# amd+nfs_host:
@# /.amd_mnt/scrn/0s1/usr1/home/jhs/._dir/public_html/src/fixes.html
@# So ${.CURDIR}/${.TARGET} works on localhost, but fails on
@# amd+nfs_host, so I used to use ${.TARGET} without prefix ${.CURDIR}/
@# But that created some .html in /usr/obj & failed to update web. so use
@# ${.CURDIR}/`basename ${.TARGET}`
@# ----------
@${ECHO_BUILD} "${.CURDIR}/`basename ${.TARGET}`: ${.IMPSRC}"
echo "" > ${.CURDIR}/`basename ${.TARGET}`
@# Do not echo "edit ${.IMPSRC}"
@# as that may be built from something else.
.if defined(NO_SIDEBAR)
@# Include main page &
@# Strip end of page, so I can append my tail.
grep -i -v '' ${.IMPSRC} | grep -i -v '