freepascal.compiler/packages/Makefile

#
# Makefile generated by fpcmake v0.99.13 [2000/01/06]
#

defaultrule: all

#####################################################################
# Autodetect OS (Linux or Dos or Windows NT)
# define inlinux when running under linux
# define inWinNT when running under WinNT
#####################################################################

# We need only / in the path
override PATH:=$(subst \,/,$(PATH))

# Search for PWD and determine also if we are under linux
PWD:=$(strip $(wildcard $(addsuffix /pwd.exe,$(subst ;, ,$(PATH)))))
ifeq ($(PWD),)
PWD:=$(strip $(wildcard $(addsuffix /pwd,$(subst :, ,$(PATH)))))
ifeq ($(PWD),)
nopwd:
	@echo You need the GNU utils package to use this Makefile!
	@echo Get ftp://ftp.freepascal.org/pub/fpc/dist/go32v2/utilgo32.zip
	@exit
else
inlinux=1
endif
else
PWD:=$(firstword $(PWD))
endif

# Detect NT - NT sets OS to Windows_NT
ifndef inlinux
ifeq ($(OS),Windows_NT)
inWinNT=1
endif
endif

# Detect OS/2 - OS/2 has OS2_SHELL defined
ifndef inlinux
ifndef inWinNT
ifdef OS2_SHELL
inOS2=1
endif
endif
endif

# The extension of executables
ifdef inlinux
EXEEXT=
else
EXEEXT=.exe
endif

# The path which is searched separated by spaces
ifdef inlinux
SEARCHPATH=$(subst :, ,$(PATH))
else
SEARCHPATH=$(subst ;, ,$(PATH))
endif

#####################################################################
# FPC version/target Detection
#####################################################################

# What compiler to use ?
ifndef FPC
# Compatibility with old makefiles
ifdef PP
FPC=$(PP)
else
ifdef inOS2
FPC=ppos2$(EXEEXT)
else
FPC=ppc386$(EXEEXT)
endif
endif
endif

# Target OS
ifndef OS_TARGET
OS_TARGET:=$(shell $(FPC) -iTO)
endif

# Source OS
ifndef OS_SOURCE
OS_SOURCE:=$(shell $(FPC) -iSO)
endif

# Target CPU
ifndef CPU_TARGET
CPU_TARGET:=$(shell $(FPC) -iTP)
endif

# Source CPU
ifndef CPU_SOURCE
CPU_SOURCE:=$(shell $(FPC) -iSP)
endif

# FPC version
ifndef FPC_VERSION
FPC_VERSION:=$(shell $(FPC) -iV)
endif

export FPC OS_TARGET OS_SOURCE CPU_TARGET CPU_SOURCE FPC_VERSION

# Test FPCDIR to look if the RTL dir exists
ifdef FPCDIR
override FPCDIR:=$(subst \,/,$(FPCDIR))
ifeq ($(wildcard $(FPCDIR)/rtl),)
override FPCDIR=wrong
endif
else
override FPCDIR=wrong
endif

# Detect FPCDIR
ifeq ($(FPCDIR),wrong)
ifdef inlinux
override FPCDIR=/usr/lib/fpc/$(FPC_VERSION)
else
override FPCDIR:=$(subst /$(FPC)$(EXEEXT),,$(firstword $(strip $(wildcard $(addsuffix /$(FPC)$(EXEEXT),$(SEARCHPATH))))))
endif
endif

ifndef PACKAGEDIR
PACKAGEDIR=$(FPCDIR)/packages
endif
ifndef COMPONENTDIR
COMPONENTDIR=$(FPCDIR)/components
endif
# Create units dir
ifneq ($(FPCDIR),.)
UNITSDIR=$(FPCDIR)/units/$(OS_TARGET)
endif

# Check if the dirs really exists, else turn it off
ifeq ($(wildcard $(UNITSDIR)),)
UNITSDIR=
endif
ifeq ($(wildcard $(PACKAGEDIR)),)
PACKAGEDIR=
endif
ifeq ($(wildcard $(COMPONENTDIR)),)
COMPONENTDIR=
endif

#####################################################################
# Default Settings
#####################################################################

# Release ? Then force OPT and don't use extra opts via commandline
ifndef REDIRFILE
REDIRFILE=log
endif

ifdef REDIR
ifndef inlinux
override FPC=redir -eo $(FPC)
endif
# set the verbosity to max
override OPT+=-va
override REDIR:= >> $(REDIRFILE)
endif

#####################################################################
# User Settings
#####################################################################


# Targets

override DIROBJECTS+=$(wildcard ibase mysql uncgi paszlib)
ifeq ($(OS_TARGET),linux)
override DIROBJECTS+=$(wildcard gtk opengl gdbint utmp inet postgres ncurses x11 forms svgalib ggi zlib)
endif
ifeq ($(OS_TARGET),go32v2)
override DIROBJECTS+=$(wildcard gdbint)
endif
ifeq ($(OS_TARGET),win32)
override DIROBJECTS+=$(wildcard gtk opengl gdbint)
endif

# Clean


# Install

ZIPTARGET=install

# Defaults


# Directories


# Packages

override PACKAGES+=rtl
ifneq ($(wildcard $(FPCDIR)/rtl),)
ifneq ($(wildcard $(FPCDIR)/rtl/$(OS_TARGET)),)
PACKAGEDIR_RTL=$(FPCDIR)/rtl/$(OS_TARGET)
else
PACKAGEDIR_RTL=$(FPCDIR)/rtl
endif
UNITDIR_RTL=$(PACKAGEDIR_RTL)
else
PACKAGEDIR_RTL=
ifneq ($(wildcard $(UNITSDIR)/rtl),)
ifneq ($(wildcard $(UNITSDIR)/rtl/$(OS_TARGET)),)
UNITDIR_RTL=$(UNITSDIR)/rtl/$(OS_TARGET)
else
UNITDIR_RTL=$(UNITSDIR)/rtl
endif
else
UNITDIR_RTL=
endif
endif
ifdef UNITDIR_RTL
override NEEDUNITDIR+=$(UNITDIR_RTL)
endif

# Libraries


#####################################################################
# Standard rules
#####################################################################

all: $(addsuffix _all,$(DIROBJECTS))

debug: $(addsuffix _debug,$(DIROBJECTS))

examples: $(addsuffix _examples,$(DIROBJECTS))

test: $(addsuffix _test,$(DIROBJECTS))

smart: $(addsuffix _smart,$(DIROBJECTS))

shared: $(addsuffix _shared,$(DIROBJECTS))

showinstall: $(addsuffix _showinstall,$(DIROBJECTS))

install: $(addsuffix _install,$(DIROBJECTS))

sourceinstall: $(addsuffix _sourceinstall,$(DIROBJECTS))

clean: $(addsuffix _clean,$(DIROBJECTS))

cleanall: $(addsuffix _cleanall,$(DIROBJECTS))

require: $(addsuffix _require,$(DIROBJECTS))

.PHONY:  all debug examples test smart shared showinstall install sourceinstall clean cleanall require


ifdef PACKAGERTL
ifneq ($(wildcard $(PACKAGEDIR_RTL)),)
ifeq ($(wildcard $(PACKAGEDIR_RTL)/$(FPCMADE)),)
override COMPILEPACKAGES+=rtl
rtl_package:
	$(MAKE) -C $(PACKAGEDIR_RTL) all
endif
endif
endif

PACKAGERTL=1
ifdef PACKAGERTL
ifneq ($(wildcard $(PACKAGEDIR_RTL)),)
ifeq ($(wildcard $(PACKAGEDIR_RTL)/$(FPCMADE)),)
override COMPILEPACKAGES+=rtl
rtl_package:
	$(MAKE) -C $(PACKAGEDIR_RTL) all
endif
endif
endif

.PHONY:  rtl_package rtl_package


# Target Dirs

OBJECTDIRIBASE=1
OBJECTDIRMYSQL=1
OBJECTDIRUNCGI=1
OBJECTDIRPASZLIB=1
ifeq ($(OS_TARGET),linux)
OBJECTDIRGTK=1
OBJECTDIROPENGL=1
OBJECTDIRGDBINT=1
OBJECTDIRUTMP=1
OBJECTDIRINET=1
OBJECTDIRPOSTGRES=1
OBJECTDIRNCURSES=1
OBJECTDIRX11=1
OBJECTDIRFORMS=1
OBJECTDIRSVGALIB=1
OBJECTDIRGGI=1
OBJECTDIRZLIB=1
endif
ifeq ($(OS_TARGET),go32v2)
OBJECTDIRGDBINT=1
endif
ifeq ($(OS_TARGET),win32)
OBJECTDIRGTK=1
OBJECTDIROPENGL=1
OBJECTDIRGDBINT=1
endif

# Dir ibase

ifdef OBJECTDIRIBASE
.PHONY:  ibase_all ibase_debug ibase_examples ibase_test ibase_smart ibase_shared ibase_showinstall ibase_install ibase_sourceinstall ibase_zipinstall ibase_zipinstalladd ibase_clean ibase_cleanall ibase_require ibase_info

ibase_all:
	$(MAKE) -C ibase all

ibase_debug:
	$(MAKE) -C ibase debug

ibase_examples:
	$(MAKE) -C ibase examples

ibase_test:
	$(MAKE) -C ibase test

ibase_smart:
	$(MAKE) -C ibase smart

ibase_shared:
	$(MAKE) -C ibase shared

ibase_showinstall:
	$(MAKE) -C ibase showinstall

ibase_install:
	$(MAKE) -C ibase install

ibase_sourceinstall:
	$(MAKE) -C ibase sourceinstall

ibase_zipinstall:
	$(MAKE) -C ibase zipinstall

ibase_zipinstalladd:
	$(MAKE) -C ibase zipinstalladd

ibase_clean:
	$(MAKE) -C ibase clean

ibase_cleanall:
	$(MAKE) -C ibase cleanall

ibase_require:
	$(MAKE) -C ibase require

ibase_info:
	$(MAKE) -C ibase info
endif

# Dir mysql

ifdef OBJECTDIRMYSQL
.PHONY:  mysql_all mysql_debug mysql_examples mysql_test mysql_smart mysql_shared mysql_showinstall mysql_install mysql_sourceinstall mysql_zipinstall mysql_zipinstalladd mysql_clean mysql_cleanall mysql_require mysql_info

mysql_all:
	$(MAKE) -C mysql all

mysql_debug:
	$(MAKE) -C mysql debug

mysql_examples:
	$(MAKE) -C mysql examples

mysql_test:
	$(MAKE) -C mysql test

mysql_smart:
	$(MAKE) -C mysql smart

mysql_shared:
	$(MAKE) -C mysql shared

mysql_showinstall:
	$(MAKE) -C mysql showinstall

mysql_install:
	$(MAKE) -C mysql install

mysql_sourceinstall:
	$(MAKE) -C mysql sourceinstall

mysql_zipinstall:
	$(MAKE) -C mysql zipinstall

mysql_zipinstalladd:
	$(MAKE) -C mysql zipinstalladd

mysql_clean:
	$(MAKE) -C mysql clean

mysql_cleanall:
	$(MAKE) -C mysql cleanall

mysql_require:
	$(MAKE) -C mysql require

mysql_info:
	$(MAKE) -C mysql info
endif

# Dir uncgi

ifdef OBJECTDIRUNCGI
.PHONY:  uncgi_all uncgi_debug uncgi_examples uncgi_test uncgi_smart uncgi_shared uncgi_showinstall uncgi_install uncgi_sourceinstall uncgi_zipinstall uncgi_zipinstalladd uncgi_clean uncgi_cleanall uncgi_require uncgi_info

uncgi_all:
	$(MAKE) -C uncgi all

uncgi_debug:
	$(MAKE) -C uncgi debug

uncgi_examples:
	$(MAKE) -C uncgi examples

uncgi_test:
	$(MAKE) -C uncgi test

uncgi_smart:
	$(MAKE) -C uncgi smart

uncgi_shared:
	$(MAKE) -C uncgi shared

uncgi_showinstall:
	$(MAKE) -C uncgi showinstall

uncgi_install:
	$(MAKE) -C uncgi install

uncgi_sourceinstall:
	$(MAKE) -C uncgi sourceinstall

uncgi_zipinstall:
	$(MAKE) -C uncgi zipinstall

uncgi_zipinstalladd:
	$(MAKE) -C uncgi zipinstalladd

uncgi_clean:
	$(MAKE) -C uncgi clean

uncgi_cleanall:
	$(MAKE) -C uncgi cleanall

uncgi_require:
	$(MAKE) -C uncgi require

uncgi_info:
	$(MAKE) -C uncgi info
endif

# Dir paszlib

ifdef OBJECTDIRPASZLIB
.PHONY:  paszlib_all paszlib_debug paszlib_examples paszlib_test paszlib_smart paszlib_shared paszlib_showinstall paszlib_install paszlib_sourceinstall paszlib_zipinstall paszlib_zipinstalladd paszlib_clean paszlib_cleanall paszlib_require paszlib_info

paszlib_all:
	$(MAKE) -C paszlib all

paszlib_debug:
	$(MAKE) -C paszlib debug

paszlib_examples:
	$(MAKE) -C paszlib examples

paszlib_test:
	$(MAKE) -C paszlib test

paszlib_smart:
	$(MAKE) -C paszlib smart

paszlib_shared:
	$(MAKE) -C paszlib shared

paszlib_showinstall:
	$(MAKE) -C paszlib showinstall

paszlib_install:
	$(MAKE) -C paszlib install

paszlib_sourceinstall:
	$(MAKE) -C paszlib sourceinstall

paszlib_zipinstall:
	$(MAKE) -C paszlib zipinstall

paszlib_zipinstalladd:
	$(MAKE) -C paszlib zipinstalladd

paszlib_clean:
	$(MAKE) -C paszlib clean

paszlib_cleanall:
	$(MAKE) -C paszlib cleanall

paszlib_require:
	$(MAKE) -C paszlib require

paszlib_info:
	$(MAKE) -C paszlib info
endif

# Dir gtk

ifdef OBJECTDIRGTK
.PHONY:  gtk_all gtk_debug gtk_examples gtk_test gtk_smart gtk_shared gtk_showinstall gtk_install gtk_sourceinstall gtk_zipinstall gtk_zipinstalladd gtk_clean gtk_cleanall gtk_require gtk_info

gtk_all:
	$(MAKE) -C gtk all

gtk_debug:
	$(MAKE) -C gtk debug

gtk_examples:
	$(MAKE) -C gtk examples

gtk_test:
	$(MAKE) -C gtk test

gtk_smart:
	$(MAKE) -C gtk smart

gtk_shared:
	$(MAKE) -C gtk shared

gtk_showinstall:
	$(MAKE) -C gtk showinstall

gtk_install:
	$(MAKE) -C gtk install

gtk_sourceinstall:
	$(MAKE) -C gtk sourceinstall

gtk_zipinstall:
	$(MAKE) -C gtk zipinstall

gtk_zipinstalladd:
	$(MAKE) -C gtk zipinstalladd

gtk_clean:
	$(MAKE) -C gtk clean

gtk_cleanall:
	$(MAKE) -C gtk cleanall

gtk_require:
	$(MAKE) -C gtk require

gtk_info:
	$(MAKE) -C gtk info
endif

# Dir opengl

ifdef OBJECTDIROPENGL
.PHONY:  opengl_all opengl_debug opengl_examples opengl_test opengl_smart opengl_shared opengl_showinstall opengl_install opengl_sourceinstall opengl_zipinstall opengl_zipinstalladd opengl_clean opengl_cleanall opengl_require opengl_info

opengl_all:
	$(MAKE) -C opengl all

opengl_debug:
	$(MAKE) -C opengl debug

opengl_examples:
	$(MAKE) -C opengl examples

opengl_test:
	$(MAKE) -C opengl test

opengl_smart:
	$(MAKE) -C opengl smart

opengl_shared:
	$(MAKE) -C opengl shared

opengl_showinstall:
	$(MAKE) -C opengl showinstall

opengl_install:
	$(MAKE) -C opengl install

opengl_sourceinstall:
	$(MAKE) -C opengl sourceinstall

opengl_zipinstall:
	$(MAKE) -C opengl zipinstall

opengl_zipinstalladd:
	$(MAKE) -C opengl zipinstalladd

opengl_clean:
	$(MAKE) -C opengl clean

opengl_cleanall:
	$(MAKE) -C opengl cleanall

opengl_require:
	$(MAKE) -C opengl require

opengl_info:
	$(MAKE) -C opengl info
endif

# Dir gdbint

ifdef OBJECTDIRGDBINT
.PHONY:  gdbint_all gdbint_debug gdbint_examples gdbint_test gdbint_smart gdbint_shared gdbint_showinstall gdbint_install gdbint_sourceinstall gdbint_zipinstall gdbint_zipinstalladd gdbint_clean gdbint_cleanall gdbint_require gdbint_info

gdbint_all:
	$(MAKE) -C gdbint all

gdbint_debug:
	$(MAKE) -C gdbint debug

gdbint_examples:
	$(MAKE) -C gdbint examples

gdbint_test:
	$(MAKE) -C gdbint test

gdbint_smart:
	$(MAKE) -C gdbint smart

gdbint_shared:
	$(MAKE) -C gdbint shared

gdbint_showinstall:
	$(MAKE) -C gdbint showinstall

gdbint_install:
	$(MAKE) -C gdbint install

gdbint_sourceinstall:
	$(MAKE) -C gdbint sourceinstall

gdbint_zipinstall:
	$(MAKE) -C gdbint zipinstall

gdbint_zipinstalladd:
	$(MAKE) -C gdbint zipinstalladd

gdbint_clean:
	$(MAKE) -C gdbint clean

gdbint_cleanall:
	$(MAKE) -C gdbint cleanall

gdbint_require:
	$(MAKE) -C gdbint require

gdbint_info:
	$(MAKE) -C gdbint info
endif

# Dir utmp

ifdef OBJECTDIRUTMP
.PHONY:  utmp_all utmp_debug utmp_examples utmp_test utmp_smart utmp_shared utmp_showinstall utmp_install utmp_sourceinstall utmp_zipinstall utmp_zipinstalladd utmp_clean utmp_cleanall utmp_require utmp_info

utmp_all:
	$(MAKE) -C utmp all

utmp_debug:
	$(MAKE) -C utmp debug

utmp_examples:
	$(MAKE) -C utmp examples

utmp_test:
	$(MAKE) -C utmp test

utmp_smart:
	$(MAKE) -C utmp smart

utmp_shared:
	$(MAKE) -C utmp shared

utmp_showinstall:
	$(MAKE) -C utmp showinstall

utmp_install:
	$(MAKE) -C utmp install

utmp_sourceinstall:
	$(MAKE) -C utmp sourceinstall

utmp_zipinstall:
	$(MAKE) -C utmp zipinstall

utmp_zipinstalladd:
	$(MAKE) -C utmp zipinstalladd

utmp_clean:
	$(MAKE) -C utmp clean

utmp_cleanall:
	$(MAKE) -C utmp cleanall

utmp_require:
	$(MAKE) -C utmp require

utmp_info:
	$(MAKE) -C utmp info
endif

# Dir inet

ifdef OBJECTDIRINET
.PHONY:  inet_all inet_debug inet_examples inet_test inet_smart inet_shared inet_showinstall inet_install inet_sourceinstall inet_zipinstall inet_zipinstalladd inet_clean inet_cleanall inet_require inet_info

inet_all:
	$(MAKE) -C inet all

inet_debug:
	$(MAKE) -C inet debug

inet_examples:
	$(MAKE) -C inet examples

inet_test:
	$(MAKE) -C inet test

inet_smart:
	$(MAKE) -C inet smart

inet_shared:
	$(MAKE) -C inet shared

inet_showinstall:
	$(MAKE) -C inet showinstall

inet_install:
	$(MAKE) -C inet install

inet_sourceinstall:
	$(MAKE) -C inet sourceinstall

inet_zipinstall:
	$(MAKE) -C inet zipinstall

inet_zipinstalladd:
	$(MAKE) -C inet zipinstalladd

inet_clean:
	$(MAKE) -C inet clean

inet_cleanall:
	$(MAKE) -C inet cleanall

inet_require:
	$(MAKE) -C inet require

inet_info:
	$(MAKE) -C inet info
endif

# Dir postgres

ifdef OBJECTDIRPOSTGRES
.PHONY:  postgres_all postgres_debug postgres_examples postgres_test postgres_smart postgres_shared postgres_showinstall postgres_install postgres_sourceinstall postgres_zipinstall postgres_zipinstalladd postgres_clean postgres_cleanall postgres_require postgres_info

postgres_all:
	$(MAKE) -C postgres all

postgres_debug:
	$(MAKE) -C postgres debug

postgres_examples:
	$(MAKE) -C postgres examples

postgres_test:
	$(MAKE) -C postgres test

postgres_smart:
	$(MAKE) -C postgres smart

postgres_shared:
	$(MAKE) -C postgres shared

postgres_showinstall:
	$(MAKE) -C postgres showinstall

postgres_install:
	$(MAKE) -C postgres install

postgres_sourceinstall:
	$(MAKE) -C postgres sourceinstall

postgres_zipinstall:
	$(MAKE) -C postgres zipinstall

postgres_zipinstalladd:
	$(MAKE) -C postgres zipinstalladd

postgres_clean:
	$(MAKE) -C postgres clean

postgres_cleanall:
	$(MAKE) -C postgres cleanall

postgres_require:
	$(MAKE) -C postgres require

postgres_info:
	$(MAKE) -C postgres info
endif

# Dir ncurses

ifdef OBJECTDIRNCURSES
.PHONY:  ncurses_all ncurses_debug ncurses_examples ncurses_test ncurses_smart ncurses_shared ncurses_showinstall ncurses_install ncurses_sourceinstall ncurses_zipinstall ncurses_zipinstalladd ncurses_clean ncurses_cleanall ncurses_require ncurses_info

ncurses_all:
	$(MAKE) -C ncurses all

ncurses_debug:
	$(MAKE) -C ncurses debug

ncurses_examples:
	$(MAKE) -C ncurses examples

ncurses_test:
	$(MAKE) -C ncurses test

ncurses_smart:
	$(MAKE) -C ncurses smart

ncurses_shared:
	$(MAKE) -C ncurses shared

ncurses_showinstall:
	$(MAKE) -C ncurses showinstall

ncurses_install:
	$(MAKE) -C ncurses install

ncurses_sourceinstall:
	$(MAKE) -C ncurses sourceinstall

ncurses_zipinstall:
	$(MAKE) -C ncurses zipinstall

ncurses_zipinstalladd:
	$(MAKE) -C ncurses zipinstalladd

ncurses_clean:
	$(MAKE) -C ncurses clean

ncurses_cleanall:
	$(MAKE) -C ncurses cleanall

ncurses_require:
	$(MAKE) -C ncurses require

ncurses_info:
	$(MAKE) -C ncurses info
endif

# Dir x11

ifdef OBJECTDIRX11
.PHONY:  x11_all x11_debug x11_examples x11_test x11_smart x11_shared x11_showinstall x11_install x11_sourceinstall x11_zipinstall x11_zipinstalladd x11_clean x11_cleanall x11_require x11_info

x11_all:
	$(MAKE) -C x11 all

x11_debug:
	$(MAKE) -C x11 debug

x11_examples:
	$(MAKE) -C x11 examples

x11_test:
	$(MAKE) -C x11 test

x11_smart:
	$(MAKE) -C x11 smart

x11_shared:
	$(MAKE) -C x11 shared

x11_showinstall:
	$(MAKE) -C x11 showinstall

x11_install:
	$(MAKE) -C x11 install

x11_sourceinstall:
	$(MAKE) -C x11 sourceinstall

x11_zipinstall:
	$(MAKE) -C x11 zipinstall

x11_zipinstalladd:
	$(MAKE) -C x11 zipinstalladd

x11_clean:
	$(MAKE) -C x11 clean

x11_cleanall:
	$(MAKE) -C x11 cleanall

x11_require:
	$(MAKE) -C x11 require

x11_info:
	$(MAKE) -C x11 info
endif

# Dir forms

ifdef OBJECTDIRFORMS
.PHONY:  forms_all forms_debug forms_examples forms_test forms_smart forms_shared forms_showinstall forms_install forms_sourceinstall forms_zipinstall forms_zipinstalladd forms_clean forms_cleanall forms_require forms_info

forms_all:
	$(MAKE) -C forms all

forms_debug:
	$(MAKE) -C forms debug

forms_examples:
	$(MAKE) -C forms examples

forms_test:
	$(MAKE) -C forms test

forms_smart:
	$(MAKE) -C forms smart

forms_shared:
	$(MAKE) -C forms shared

forms_showinstall:
	$(MAKE) -C forms showinstall

forms_install:
	$(MAKE) -C forms install

forms_sourceinstall:
	$(MAKE) -C forms sourceinstall

forms_zipinstall:
	$(MAKE) -C forms zipinstall

forms_zipinstalladd:
	$(MAKE) -C forms zipinstalladd

forms_clean:
	$(MAKE) -C forms clean

forms_cleanall:
	$(MAKE) -C forms cleanall

forms_require:
	$(MAKE) -C forms require

forms_info:
	$(MAKE) -C forms info
endif

# Dir svgalib

ifdef OBJECTDIRSVGALIB
.PHONY:  svgalib_all svgalib_debug svgalib_examples svgalib_test svgalib_smart svgalib_shared svgalib_showinstall svgalib_install svgalib_sourceinstall svgalib_zipinstall svgalib_zipinstalladd svgalib_clean svgalib_cleanall svgalib_require svgalib_info

svgalib_all:
	$(MAKE) -C svgalib all

svgalib_debug:
	$(MAKE) -C svgalib debug

svgalib_examples:
	$(MAKE) -C svgalib examples

svgalib_test:
	$(MAKE) -C svgalib test

svgalib_smart:
	$(MAKE) -C svgalib smart

svgalib_shared:
	$(MAKE) -C svgalib shared

svgalib_showinstall:
	$(MAKE) -C svgalib showinstall

svgalib_install:
	$(MAKE) -C svgalib install

svgalib_sourceinstall:
	$(MAKE) -C svgalib sourceinstall

svgalib_zipinstall:
	$(MAKE) -C svgalib zipinstall

svgalib_zipinstalladd:
	$(MAKE) -C svgalib zipinstalladd

svgalib_clean:
	$(MAKE) -C svgalib clean

svgalib_cleanall:
	$(MAKE) -C svgalib cleanall

svgalib_require:
	$(MAKE) -C svgalib require

svgalib_info:
	$(MAKE) -C svgalib info
endif

# Dir ggi

ifdef OBJECTDIRGGI
.PHONY:  ggi_all ggi_debug ggi_examples ggi_test ggi_smart ggi_shared ggi_showinstall ggi_install ggi_sourceinstall ggi_zipinstall ggi_zipinstalladd ggi_clean ggi_cleanall ggi_require ggi_info

ggi_all:
	$(MAKE) -C ggi all

ggi_debug:
	$(MAKE) -C ggi debug

ggi_examples:
	$(MAKE) -C ggi examples

ggi_test:
	$(MAKE) -C ggi test

ggi_smart:
	$(MAKE) -C ggi smart

ggi_shared:
	$(MAKE) -C ggi shared

ggi_showinstall:
	$(MAKE) -C ggi showinstall

ggi_install:
	$(MAKE) -C ggi install

ggi_sourceinstall:
	$(MAKE) -C ggi sourceinstall

ggi_zipinstall:
	$(MAKE) -C ggi zipinstall

ggi_zipinstalladd:
	$(MAKE) -C ggi zipinstalladd

ggi_clean:
	$(MAKE) -C ggi clean

ggi_cleanall:
	$(MAKE) -C ggi cleanall

ggi_require:
	$(MAKE) -C ggi require

ggi_info:
	$(MAKE) -C ggi info
endif

# Dir zlib

ifdef OBJECTDIRZLIB
.PHONY:  zlib_all zlib_debug zlib_examples zlib_test zlib_smart zlib_shared zlib_showinstall zlib_install zlib_sourceinstall zlib_zipinstall zlib_zipinstalladd zlib_clean zlib_cleanall zlib_require zlib_info

zlib_all:
	$(MAKE) -C zlib all

zlib_debug:
	$(MAKE) -C zlib debug

zlib_examples:
	$(MAKE) -C zlib examples

zlib_test:
	$(MAKE) -C zlib test

zlib_smart:
	$(MAKE) -C zlib smart

zlib_shared:
	$(MAKE) -C zlib shared

zlib_showinstall:
	$(MAKE) -C zlib showinstall

zlib_install:
	$(MAKE) -C zlib install

zlib_sourceinstall:
	$(MAKE) -C zlib sourceinstall

zlib_zipinstall:
	$(MAKE) -C zlib zipinstall

zlib_zipinstalladd:
	$(MAKE) -C zlib zipinstalladd

zlib_clean:
	$(MAKE) -C zlib clean

zlib_cleanall:
	$(MAKE) -C zlib cleanall

zlib_require:
	$(MAKE) -C zlib require

zlib_info:
	$(MAKE) -C zlib info
endif