# Eigen Compiler Suite makefile
# Copyright (C) Florian Negele

# This file is part of the Eigen Compiler Suite.

# The ECS is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# The ECS is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with the ECS.  If not, see <https://www.gnu.org/licenses/>.

all: tools runtime utilities
commit: tools runtime utilities documentation checks tests
.PHONY: all commit tools utilities runtime documentation tests checks clean dependencies install uninstall

.SUFFIXES: # delete the default suffixes
MAKEFLAGS += --no-builtin-rules --no-builtin-variables

# common definitions

languages := cd cpp fal ob asm
languagenames := CODE CPP FALSE OBERON ASSEMBLY
languagenamespaces := code cpp false oberon assembly
preprocessors := $(filter cppprep, $(addsuffix prep, $(languages)))
printers := $(filter-out cdprint, $(addsuffix print, $(languages)))
checkers := $(filter-out asmcheck, $(addsuffix check, $(languages)))
serializers := $(filter-out cddump asmdump, $(addsuffix dump, $(languages)))
interpreters := $(filter-out asmrun, $(addsuffix run, $(languages)))
transpilers := $(filter-out cdcpp cppcpp asmcpp, $(addsuffix cpp, $(languages)))

extractors := doc cpp ob
extractornames := DOCUMENTATION CPP OBERON
formatters := doc html latex
formatternames := DOCUMENTATION HTML LATEX
generators := $(filter-out docdoc, $(foreach extractor, $(extractors), $(addprefix $(extractor), $(formatters))))

frontends := cd cpp fal ob
frontendnames := CODE CPP FALSE OBERON
backends := code amd16 amd32 amd64 arma32 arma64 armt32 armt32fpe avr avrxt avr32 m68k mibl mips32 mips64 mmix or1k ppc32 ppc64 risc wasm xtensa
backendnames := CODE AMD16 AMD32 AMD64 ARMA32 ARMA64 ARMT32 ARMT32FPE AVR AVRXT AVR32 M68K MICROBLAZE MIPS32 MIPS64 MMIX OR1K POWERPC32 POWERPC64 RISC WEBASSEMBLY XTENSA
compilers := $(filter-out cdcode, $(foreach frontend, $(frontends), $(addprefix $(frontend), $(backends))))

targets := $(filter-out code, $(backends))
targetnames := $(filter-out CODE, $(backendnames))

debugfileformats := dwarf
debugfileformatnames := DWARF
converters := $(addprefix dbg, $(debugfileformats))

architectures := $(filter-out armt32fpe avrxt, $(targets))
architecturenames := $(filter-out ARMT32FPE AVRXT, $(targetnames))
assemblers := $(addsuffix asm, $(architectures))
disassemblers := $(addsuffix dism, $(architectures))

linkfileformats := lib bin mem hex prg
linkfileformatnames := LIBRARY BINARY MEMORY INTELHEX GEMDOS
linkers := $(addprefix link, $(linkfileformats))

environments := amd32darwin amd32linux amd64darwin amd64linux arma32linux arma64darwin arma64linux armt32linux armt32fpelinux at32uc3a3 atmega32 atmega328 atmega8515 axtmega2560 bios16 bios32 bios64 dos efi32 efi64 m68klinux mips32linux mips64linux mmixsim or1klinux or1ksim riscdisk rpi2b tos webassembly win32 win64 xtensalinux
environmenttargets := amd32 amd32 amd64 amd64 arma32 arma64 arma64 armt32 armt32fpe avr32 avrxt avr avr avr amd16 amd32 amd64 amd16 amd32 amd64 m68k mips32 mips64 mmix or1k or1k risc arma32 m68k wasm amd32 amd64 xtensa
environmentarchitectures := amd32 amd32 amd64 amd64 arma32 arma64 arma64 armt32 armt32 avr32 avr avr avr avr amd16 amd32 amd64 amd16 amd32 amd64 m68k mips32 mips64 mmix or1k or1k risc arma32 m68k wasm amd32 amd64 xtensa

find = $(if $(findstring $(lastword $2), $1), $(words $2), $(call find, $1, $(filter-out $(lastword $2), $2)))
lookup = $(word $(call find, $1, $(call $2s)), $(call $(addprefix $2, $3)s))

# environment

ifndef environment

	ifdef MSYSTEM
		environment := posix
	else ifdef windir
		environment := windows
	else
		environment := posix
	endif

endif

ifeq "$(environment)" "posix"

	rm := rm -f
	tc := touch
	mv := mv
	md := mkdir
	rd := rm -rf

	prg :=
	path = $1
	pathp = $1
	nul := /dev/null

	kernel := $(shell uname -s)
	ifeq "$(kernel)" "Linux"

		environment := linux.cpp posix.cpp ansi.cpp

		machine := $(shell uname -m)
		ifeq "$(machine)" "i686"
			hostenvironments := amd32linux
		else ifeq "$(machine)" "x86_64"
			hostenvironments := amd64linux
		else ifeq "$(machine)" "armv7l"
			hostenvironments := arma32linux armt32linux armt32fpelinux
		else ifeq "$(machine)" "armv8l"
			hostenvironments := arma32linux armt32linux armt32fpelinux
		else ifeq "$(machine)" "aarch64"
			hostenvironments := arma64linux
		else ifeq "$(machine)" "mips"
			hostenvironments := mips32linux
		else
			hostenvironments :=
		endif

		ifndef toolchain
			toolchain := gcc
		endif

	else ifeq "$(kernel)" "Darwin"

		environment := darwin.cpp posix.cpp ansi.cpp
		machine := $(shell uname -m)
		ifeq "$(machine)" "i686"
			hostenvironments := amd32darwin
		else ifeq "$(machine)" "x86_64"
			hostenvironments := amd32darwin amd64darwin
		else ifeq "$(machine)" "arm64"
			hostenvironments := arma64darwin
		else
			hostenvironments :=
		endif

		ifndef toolchain
			toolchain := clang
		endif

	else ifeq "$(kernel)" "FreeBSD"

		environment := freebsd.cpp posix.cpp ansi.cpp
		hostenvironments :=

		ifndef toolchain
			toolchain := clang
		endif

	else
		environment := $(error unknown posix environment)
	endif

else ifeq "$(environment)" "windows"

	rm := del /q 2>nul >nul
	tc := type nul >
	mv := move >nul
	md := mkdir
	rd := del /q /s 2>nul >nul

	prg := .exe
	path = $(subst /,\,$1)
	pathp = $(subst /,\\,$1)
	nul := nul

	environment := windows.cpp

	ifdef CommonProgramFiles(x86)
		hostenvironments := win32 win64
	else
		hostenvironments := dos win32
	endif

	ifndef toolchain
		toolchain := msvc
	endif

else
	environment := $(error unknown environment)
endif

# toolchain

ifeq "$(toolchain)" "ecs"

	o := .obf
	cc := ecsd
	ld := ecsd

	cflags = -c -s cpp
	lflags = -C

	ccheckflags := -i cppcheck
	crunflags := -c
	lrunflags := -C

else ifeq "$(toolchain)" "gcc"

	o := .o
	cc := g++
	ld := g++

	commonflags := -c -pipe -x c++ -std=c++17 --pedantic -Wfatal-errors

	cflags = $(commonflags) -Werror -Wall -Wextra -Wmissing-noreturn -Wno-switch -Wno-empty-body -Wno-parentheses -Wzero-as-null-pointer-constant -Wno-missing-field-initializers -Wno-return-type -Wno-misleading-indentation -Wno-psabi -Wno-implicit-fallthrough -Wno-suggest-attribute=noreturn -o $(notdir $@)
	lflags = -o $(notdir $@)

	ccheckflags := $(commonflags) -fsyntax-only
	crunflags := $(commonflags)
	lrunflags := -o

else ifeq "$(toolchain)" "clang"

	o := .o
	cc := clang++
	ld := clang++

	commonflags := -c -pipe -x c++ -std=c++17 -pedantic -Wfatal-errors -Wno-nested-anon-types

	cflags = $(commonflags) -fbracket-depth=4000 -Wall -Wextra -Wmissing-noreturn -Wno-switch -Wno-empty-body -Wno-parentheses -Wno-dangling-else -Wno-unused-private-field -Wno-missing-field-initializers -Wno-overloaded-virtual -Wno-missing-braces -Wno-misleading-indentation -Wno-bitwise-instead-of-logical -o $(notdir $@)
	lflags = -Wno-unused-command-line-argument -o $(notdir $@)

	ccheckflags := $(commonflags) -fsyntax-only -Wno-dangling-else -Wno-parentheses
	crunflags := $(commonflags)
	lrunflags := -Wno-unused-command-line-argument -o

else ifeq "$(toolchain)" "msvc"

	o := .obj
	cc := cl
	ld := link

	commonflags := /EHsc /Wp64 /WL /W4 /wd4267 /wd4611 /wd4800 /GF /GR /J /c /TP

	cflags = $(commonflags) /Za /WX /Fo$(notdir $@)
	lflags = /nologo /machine:x86 /out:$(notdir $@)

	ccheckflags := $(commonflags) /we4002 /we4003 /we4005 /Za /Zs
	crunflags := $(commonflags)
	lrunflags := /nologo /machine:x86 /out:

else
	cc := $(error unknown toolchain)
endif

# directories

curr := $(call path,./)
prev := $(call path,../)

tools := $(call path,tools/)
toolsp := $(call pathp,tools/)

utilities := $(call path,utilities/)
utilitiesp := $(call pathp,utilities/)

runtime := $(call path,runtime/)
runtimep := $(call pathp,runtime/)

cpplibrary := $(call path,libraries/cpp/)
apilibrary := $(call path,libraries/cpp/api/)
deflibrary := $(call path,libraries/cpp/def/)
oblibrary := $(call path,libraries/oberon/)

documentation := $(call path,documentation/)
documentationp := $(call pathp,documentation/)

tests := $(call path,tests/)
testsp := $(call pathp,tests/)

# output of make dependencies

tools_object.hpp := $(tools)object.hpp
tools_utilities.hpp := $(tools)utilities.hpp
tools_object.cpp := $(tools)object.cpp $(tools_object.hpp) $(tools_utilities.hpp)
tools_charset.hpp := $(tools)charset.hpp
tools_diagnostics.hpp := $(tools)diagnostics.hpp
tools_error.hpp := $(tools)error.hpp
tools_format.hpp := $(tools)format.hpp
tools_objmap.hpp := $(tools)objmap.hpp $(tools_object.hpp)
tools_objlinker.hpp := $(tools)objlinker.hpp $(tools_objmap.hpp)
tools_position.hpp := $(tools)position.hpp
tools_objlinker.cpp := $(tools)objlinker.cpp $(tools_charset.hpp) $(tools_diagnostics.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_objlinker.hpp) $(tools_position.hpp) $(tools_utilities.hpp)
tools_objmap.cpp := $(tools)objmap.cpp $(tools_objmap.hpp) $(tools_utilities.hpp)
tools_objhexfile.hpp := $(tools)objhexfile.hpp
tools_objhexfile.cpp := $(tools)objhexfile.cpp $(tools_objhexfile.hpp) $(tools_utilities.hpp)
tools_strdiagnostics.hpp := $(tools)strdiagnostics.hpp $(tools_diagnostics.hpp) $(tools_position.hpp)
tools_driver.hpp := $(tools)driver.hpp $(tools_error.hpp) $(tools_format.hpp) $(tools_strdiagnostics.hpp)
tools_mapplace.cpp := $(tools)mapplace.cpp $(tools_driver.hpp) $(tools_objmap.hpp)
tools_mapsearch.cpp := $(tools)mapsearch.cpp $(tools_driver.hpp) $(tools_objmap.hpp) $(tools_utilities.hpp)
tools_debug.hpp := $(tools)debug.hpp
tools_debug.cpp := $(tools)debug.cpp $(tools_debug.hpp) $(tools_utilities.hpp)
tools_dbgconverter.hpp := $(tools)dbgconverter.hpp
tools_dbgconvertercontext.hpp := $(tools)dbgconvertercontext.hpp $(tools_dbgconverter.hpp) $(tools_debug.hpp) $(tools_object.hpp)
tools_dbgconverter.cpp := $(tools)dbgconverter.cpp $(tools_charset.hpp) $(tools_dbgconvertercontext.hpp) $(tools_diagnostics.hpp) $(tools_error.hpp) $(tools_position.hpp) $(tools_utilities.hpp)
tools_dbgdwarfconverter.hpp := $(tools)dbgdwarfconverter.hpp $(tools_dbgconverter.hpp)
tools_ieee.hpp := $(tools)ieee.hpp
tools_dbgdwarfconverter.cpp := $(tools)dbgdwarfconverter.cpp $(tools_dbgconvertercontext.hpp) $(tools_dbgdwarfconverter.hpp) $(tools_format.hpp) $(tools_ieee.hpp) $(tools_utilities.hpp)
tools_documentation.hpp := $(tools)documentation.hpp $(tools_position.hpp)
tools_documentation.cpp := $(tools)documentation.cpp $(tools_documentation.hpp)
tools_documentation.def := $(tools)documentation.def
tools_doclexer.hpp := $(tools)doclexer.hpp $(tools_documentation.def) $(tools_position.hpp)
tools_doclexer.cpp := $(tools)doclexer.cpp $(tools_doclexer.hpp) $(tools_documentation.def) $(tools_utilities.hpp)
tools_docparser.hpp := $(tools)docparser.hpp
tools_docparser.cpp := $(tools)docparser.cpp $(tools_diagnostics.hpp) $(tools_doclexer.hpp) $(tools_docparser.hpp) $(tools_documentation.hpp) $(tools_error.hpp) $(tools_format.hpp)
tools_docprinter.hpp := $(tools)docprinter.hpp
tools_docprinter.cpp := $(tools)docprinter.cpp $(tools_doclexer.hpp) $(tools_docprinter.hpp) $(tools_documentation.hpp)
tools_docprint.cpp := $(tools)docprint.cpp $(tools_docparser.hpp) $(tools_docprinter.hpp) $(tools_documentation.hpp) $(tools_driver.hpp)
tools_docchecker.hpp := $(tools)docchecker.hpp
tools_docchecker.cpp := $(tools)docchecker.cpp $(tools_diagnostics.hpp) $(tools_docchecker.hpp) $(tools_documentation.hpp) $(tools_error.hpp) $(tools_format.hpp)
tools_doccheck.cpp := $(tools)doccheck.cpp $(tools_docchecker.hpp) $(tools_docparser.hpp) $(tools_documentation.hpp) $(tools_driver.hpp)
tools_docextractor.hpp := $(tools)docextractor.hpp $(tools_docparser.hpp) $(tools_documentation.hpp)
tools_docextractor.cpp := $(tools)docextractor.cpp $(tools_diagnostics.hpp) $(tools_docextractor.hpp)
tools_dochtmlformatter.hpp := $(tools)dochtmlformatter.hpp
tools_dochtmlformatter.cpp := $(tools)dochtmlformatter.cpp $(tools_dochtmlformatter.hpp) $(tools_documentation.hpp)
tools_doclatexformatter.hpp := $(tools)doclatexformatter.hpp
tools_doclatexformatter.cpp := $(tools)doclatexformatter.cpp $(tools_doclatexformatter.hpp) $(tools_documentation.hpp) $(tools_utilities.hpp)
tools_assembly.def := $(tools)assembly.def
tools_asmlexer.hpp := $(tools)asmlexer.hpp $(tools_assembly.def) $(tools_diagnostics.hpp) $(tools_object.hpp)
tools_code.def := $(tools)code.def
tools_code.hpp := $(tools)code.hpp $(tools_code.def) $(tools_object.hpp)
tools_layout.hpp := $(tools)layout.hpp
tools_code.cpp := $(tools)code.cpp $(tools_asmlexer.hpp) $(tools_code.def) $(tools_code.hpp) $(tools_ieee.hpp) $(tools_layout.hpp) $(tools_utilities.hpp)
tools_asmchecker.hpp := $(tools)asmchecker.hpp
tools_assembly.hpp := $(tools)assembly.hpp $(tools_asmlexer.hpp)
tools_asmcheckercontext.hpp := $(tools)asmcheckercontext.hpp $(tools_asmchecker.hpp) $(tools_assembly.hpp)
tools_cdchecker.hpp := $(tools)cdchecker.hpp $(tools_asmchecker.hpp)
tools_cdchecker.cpp := $(tools)cdchecker.cpp $(tools_asmcheckercontext.hpp) $(tools_cdchecker.hpp) $(tools_code.hpp) $(tools_error.hpp) $(tools_format.hpp)
tools_cdoptimizer.hpp := $(tools)cdoptimizer.hpp
tools_cdoptimizer.cpp := $(tools)cdoptimizer.cpp $(tools_cdoptimizer.hpp) $(tools_code.hpp)
tools_asmparser.hpp := $(tools)asmparser.hpp
tools_stdlayout.hpp := $(tools)stdlayout.hpp $(tools_layout.hpp)
tools_cdgenerator.hpp := $(tools)cdgenerator.hpp $(tools_code.hpp) $(tools_stdlayout.hpp)
tools_stdcharset.hpp := $(tools)stdcharset.hpp $(tools_charset.hpp)
tools_stringpool.hpp := $(tools)stringpool.hpp
tools_cdopt.cpp := $(tools)cdopt.cpp $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_cdgenerator.hpp) $(tools_cdoptimizer.hpp) $(tools_driver.hpp) $(tools_stdcharset.hpp) $(tools_stringpool.hpp)
tools_cdinterpreter.hpp := $(tools)cdinterpreter.hpp $(tools_asmparser.hpp) $(tools_cdchecker.hpp) $(tools_code.hpp)
tools_environment.hpp := $(tools)environment.hpp
tools_cdinterpreter.cpp := $(tools)cdinterpreter.cpp $(tools_assembly.hpp) $(tools_cdinterpreter.hpp) $(tools_environment.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_position.hpp) $(tools_utilities.hpp)
tools_cdemitter.hpp := $(tools)cdemitter.hpp $(tools_asmparser.hpp) $(tools_cdchecker.hpp) $(tools_code.hpp)
tools_cdemittercontext.hpp := $(tools)cdemittercontext.hpp $(tools_cdemitter.hpp) $(tools_charset.hpp) $(tools_position.hpp) $(tools_utilities.hpp)
tools_cdemitter.cpp := $(tools)cdemitter.cpp $(tools_assembly.hpp) $(tools_cdemittercontext.hpp)
tools_cdgenerator.cpp := $(tools)cdgenerator.cpp $(tools_asmlexer.hpp) $(tools_cdgenerator.hpp) $(tools_utilities.hpp)
tools_xml.hpp := $(tools)xml.hpp
tools_xml.cpp := $(tools)xml.cpp $(tools_xml.hpp)
tools_indenter.hpp := $(tools)indenter.hpp
tools_xmlprinter.hpp := $(tools)xmlprinter.hpp
tools_xmlprinter.cpp := $(tools)xmlprinter.cpp $(tools_indenter.hpp) $(tools_xml.hpp) $(tools_xmlprinter.hpp)
tools_xmlserializer.hpp := $(tools)xmlserializer.hpp $(tools_xml.hpp)
tools_xmlserializer.cpp := $(tools)xmlserializer.cpp $(tools_position.hpp) $(tools_xmlserializer.hpp)
tools_cpp.def := $(tools)cpp.def
tools_cpplexer.hpp := $(tools)cpplexer.hpp $(tools_cpp.def) $(tools_diagnostics.hpp) $(tools_position.hpp)
tools_structurepool.hpp := $(tools)structurepool.hpp
tools_cpp.hpp := $(tools)cpp.hpp $(tools_cpp.def) $(tools_cpplexer.hpp) $(tools_structurepool.hpp)
tools_cpp.cpp := $(tools)cpp.cpp $(tools_cpp.def) $(tools_cpp.hpp) $(tools_layout.hpp) $(tools_utilities.hpp)
tools_cpplexercontext.hpp := $(tools)cpplexercontext.hpp $(tools_cpplexer.hpp)
tools_cpplexer.cpp := $(tools)cpplexer.cpp $(tools_charset.hpp) $(tools_cpp.def) $(tools_cpplexercontext.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_stringpool.hpp) $(tools_utilities.hpp)
tools_cpppreprocessor.hpp := $(tools)cpppreprocessor.hpp $(tools_cpp.def) $(tools_cpplexer.hpp)
tools_cpppreprocessorcontext.hpp := $(tools)cpppreprocessorcontext.hpp $(tools_cpp.def) $(tools_cpplexercontext.hpp) $(tools_cpppreprocessor.hpp)
tools_cpppreprocessor.cpp := $(tools)cpppreprocessor.cpp $(tools_cpp.def) $(tools_cpppreprocessorcontext.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_stringpool.hpp) $(tools_structurepool.hpp) $(tools_utilities.hpp)
tools_cppinterpreter.hpp := $(tools)cppinterpreter.hpp
tools_cppchecker.hpp := $(tools)cppchecker.hpp $(tools_cpp.hpp) $(tools_cppinterpreter.hpp)
tools_cppevaluator.hpp := $(tools)cppevaluator.hpp $(tools_cpp.hpp) $(tools_cppinterpreter.hpp)
tools_cppcheckercontext.hpp := $(tools)cppcheckercontext.hpp $(tools_cppchecker.hpp) $(tools_cppevaluator.hpp)
tools_cppparser.hpp := $(tools)cppparser.hpp $(tools_cpp.def) $(tools_cppchecker.hpp) $(tools_cpppreprocessor.hpp)
tools_cppprinter.hpp := $(tools)cppprinter.hpp
tools_cppparser.cpp := $(tools)cppparser.cpp $(tools_cpp.def) $(tools_cppcheckercontext.hpp) $(tools_cppparser.hpp) $(tools_cpppreprocessorcontext.hpp) $(tools_cppprinter.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_stringpool.hpp)
tools_cppprinter.cpp := $(tools)cppprinter.cpp $(tools_cpp.hpp) $(tools_cppprinter.hpp) $(tools_indenter.hpp) $(tools_utilities.hpp)
tools_cppexecutor.hpp := $(tools)cppexecutor.hpp $(tools_cppevaluator.hpp)
tools_cppchecker.cpp := $(tools)cppchecker.cpp $(tools_cppcheckercontext.hpp) $(tools_cppexecutor.hpp) $(tools_cppprinter.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_stringpool.hpp) $(tools_utilities.hpp)
tools_cppserializer.hpp := $(tools)cppserializer.hpp
tools_cppserializer.cpp := $(tools)cppserializer.cpp $(tools_cpp.hpp) $(tools_cppserializer.hpp) $(tools_xmlserializer.hpp)
tools_cppinterpreter.cpp := $(tools)cppinterpreter.cpp $(tools_cppexecutor.hpp) $(tools_cppprinter.hpp) $(tools_environment.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_stringpool.hpp) $(tools_utilities.hpp)
tools_cppextractor.hpp := $(tools)cppextractor.hpp
tools_cppextractor.cpp := $(tools)cppextractor.cpp $(tools_cppextractor.hpp) $(tools_docextractor.hpp)
tools_cppemitter.hpp := $(tools)cppemitter.hpp $(tools_cdemitter.hpp)
tools_cppemitter.cpp := $(tools)cppemitter.cpp $(tools_asmlexer.hpp) $(tools_cdemittercontext.hpp) $(tools_cpp.hpp) $(tools_cppemitter.hpp) $(tools_cppprinter.hpp) $(tools_error.hpp)
tools_false.def := $(tools)false.def
tools_fallexer.hpp := $(tools)fallexer.hpp $(tools_false.def) $(tools_position.hpp)
tools_false.hpp := $(tools)false.hpp $(tools_fallexer.hpp) $(tools_structurepool.hpp)
tools_false.cpp := $(tools)false.cpp $(tools_false.hpp)
tools_fallexer.cpp := $(tools)fallexer.cpp $(tools_fallexer.hpp) $(tools_false.def) $(tools_utilities.hpp)
tools_falparser.hpp := $(tools)falparser.hpp
tools_falparser.cpp := $(tools)falparser.cpp $(tools_diagnostics.hpp) $(tools_error.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falprinter.hpp := $(tools)falprinter.hpp $(tools_fallexer.hpp)
tools_falprinter.cpp := $(tools)falprinter.cpp $(tools_falprinter.hpp) $(tools_false.hpp)
tools_falserializer.hpp := $(tools)falserializer.hpp $(tools_fallexer.hpp)
tools_falserializer.cpp := $(tools)falserializer.cpp $(tools_false.hpp) $(tools_falserializer.hpp) $(tools_xmlserializer.hpp)
tools_falinterpreter.hpp := $(tools)falinterpreter.hpp
tools_falinterpreter.cpp := $(tools)falinterpreter.cpp $(tools_diagnostics.hpp) $(tools_environment.hpp) $(tools_error.hpp) $(tools_falinterpreter.hpp) $(tools_false.hpp)
tools_faltranspiler.hpp := $(tools)faltranspiler.hpp
tools_faltranspiler.cpp := $(tools)faltranspiler.cpp $(tools_false.hpp) $(tools_faltranspiler.hpp) $(tools_indenter.hpp) $(tools_utilities.hpp)
tools_falemitter.hpp := $(tools)falemitter.hpp $(tools_cdemitter.hpp)
tools_falemitter.cpp := $(tools)falemitter.cpp $(tools_cdemittercontext.hpp) $(tools_falemitter.hpp) $(tools_false.hpp)
tools_oberon.def := $(tools)oberon.def
tools_oblexer.hpp := $(tools)oblexer.hpp $(tools_oberon.def) $(tools_position.hpp)
tools_oberon.hpp := $(tools)oberon.hpp $(tools_oberon.def) $(tools_oblexer.hpp) $(tools_structurepool.hpp)
tools_oberon.cpp := $(tools)oberon.cpp $(tools_layout.hpp) $(tools_oberon.def) $(tools_oberon.hpp) $(tools_utilities.hpp)
tools_oblexer.cpp := $(tools)oblexer.cpp $(tools_oberon.def) $(tools_oblexer.hpp) $(tools_utilities.hpp)
tools_obparser.hpp := $(tools)obparser.hpp
tools_obparser.cpp := $(tools)obparser.cpp $(tools_diagnostics.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_oberon.hpp) $(tools_obparser.hpp) $(tools_utilities.hpp)
tools_obprinter.hpp := $(tools)obprinter.hpp
tools_obprinter.cpp := $(tools)obprinter.cpp $(tools_indenter.hpp) $(tools_oberon.hpp) $(tools_obprinter.hpp) $(tools_utilities.hpp)
tools_obinterpreter.hpp := $(tools)obinterpreter.hpp
tools_obchecker.hpp := $(tools)obchecker.hpp $(tools_obinterpreter.hpp) $(tools_obparser.hpp) $(tools_obprinter.hpp)
tools_obevaluator.hpp := $(tools)obevaluator.hpp $(tools_diagnostics.hpp) $(tools_oberon.def) $(tools_oberon.hpp) $(tools_obinterpreter.hpp)
tools_obchecker.cpp := $(tools)obchecker.cpp $(tools_error.hpp) $(tools_format.hpp) $(tools_obchecker.hpp) $(tools_oberon.def) $(tools_obevaluator.hpp) $(tools_utilities.hpp)
tools_obserializer.hpp := $(tools)obserializer.hpp
tools_obserializer.cpp := $(tools)obserializer.cpp $(tools_oberon.hpp) $(tools_obserializer.hpp) $(tools_xmlserializer.hpp)
tools_obinterpreter.cpp := $(tools)obinterpreter.cpp $(tools_charset.hpp) $(tools_environment.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_oberon.def) $(tools_obevaluator.hpp) $(tools_strdiagnostics.hpp) $(tools_utilities.hpp)
tools_obtranspiler.hpp := $(tools)obtranspiler.hpp
tools_obtranspiler.cpp := $(tools)obtranspiler.cpp $(tools_indenter.hpp) $(tools_oberon.hpp) $(tools_obtranspiler.hpp) $(tools_utilities.hpp)
tools_obextractor.hpp := $(tools)obextractor.hpp
tools_obextractor.cpp := $(tools)obextractor.cpp $(tools_docextractor.hpp) $(tools_indenter.hpp) $(tools_oberon.hpp) $(tools_obextractor.hpp) $(tools_utilities.hpp)
tools_obemitter.hpp := $(tools)obemitter.hpp $(tools_cdemitter.hpp)
tools_obemitter.cpp := $(tools)obemitter.cpp $(tools_cdemittercontext.hpp) $(tools_error.hpp) $(tools_obemitter.hpp) $(tools_oberon.def) $(tools_oberon.hpp) $(tools_strdiagnostics.hpp)
tools_assembly.cpp := $(tools)assembly.cpp $(tools_assembly.hpp) $(tools_utilities.hpp)
tools_asmlexer.cpp := $(tools)asmlexer.cpp $(tools_asmlexer.hpp) $(tools_assembly.def) $(tools_position.hpp) $(tools_utilities.hpp)
tools_asmparser.cpp := $(tools)asmparser.cpp $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_stringpool.hpp)
tools_asmprinter.hpp := $(tools)asmprinter.hpp
tools_asmprinter.cpp := $(tools)asmprinter.cpp $(tools_asmprinter.hpp) $(tools_assembly.hpp) $(tools_indenter.hpp)
tools_asmchecker.cpp := $(tools)asmchecker.cpp $(tools_asmcheckercontext.hpp) $(tools_charset.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_utilities.hpp)
tools_asmassembler.hpp := $(tools)asmassembler.hpp $(tools_asmchecker.hpp)
tools_asmassembler.cpp := $(tools)asmassembler.cpp $(tools_asmassembler.hpp) $(tools_asmcheckercontext.hpp) $(tools_charset.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_ieee.hpp) $(tools_utilities.hpp)
tools_asmdisassembler.hpp := $(tools)asmdisassembler.hpp
tools_asmdisassembler.cpp := $(tools)asmdisassembler.cpp $(tools_asmdisassembler.hpp) $(tools_asmlexer.hpp) $(tools_charset.hpp) $(tools_utilities.hpp)
tools_asmgenerator.hpp := $(tools)asmgenerator.hpp $(tools_asmparser.hpp) $(tools_asmprinter.hpp) $(tools_code.hpp) $(tools_layout.hpp)
tools_asmgeneratorcontext.hpp := $(tools)asmgeneratorcontext.hpp $(tools_asmgenerator.hpp) $(tools_asmlexer.hpp) $(tools_debug.hpp) $(tools_utilities.hpp)
tools_asmgenerator.cpp := $(tools)asmgenerator.cpp $(tools_asmassembler.hpp) $(tools_asmgeneratorcontext.hpp) $(tools_assembly.hpp) $(tools_error.hpp) $(tools_format.hpp) $(tools_position.hpp)
tools_amd64.def := $(tools)amd64.def
tools_amd64.hpp := $(tools)amd64.hpp $(tools_amd64.def)
tools_amd64.cpp := $(tools)amd64.cpp $(tools_amd64.def) $(tools_amd64.hpp) $(tools_object.hpp) $(tools_utilities.hpp)
tools_amd64assembler.hpp := $(tools)amd64assembler.hpp $(tools_asmassembler.hpp)
tools_amd64assembler.cpp := $(tools)amd64assembler.cpp $(tools_amd64.hpp) $(tools_amd64assembler.hpp) $(tools_utilities.hpp)
tools_amd64disassembler.hpp := $(tools)amd64disassembler.hpp $(tools_asmdisassembler.hpp)
tools_amd64disassembler.cpp := $(tools)amd64disassembler.cpp $(tools_amd64.hpp) $(tools_amd64disassembler.hpp) $(tools_utilities.hpp)
tools_amd64generator.hpp := $(tools)amd64generator.hpp $(tools_amd64assembler.hpp) $(tools_asmgenerator.hpp)
tools_amd64generator.cpp := $(tools)amd64generator.cpp $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_asmgeneratorcontext.hpp)
tools_arm.def := $(tools)arm.def
tools_arm.hpp := $(tools)arm.hpp $(tools_arm.def)
tools_arm.cpp := $(tools)arm.cpp $(tools_arm.def) $(tools_arm.hpp) $(tools_utilities.hpp)
tools_arma32.def := $(tools)arma32.def
tools_arma32.hpp := $(tools)arma32.hpp $(tools_arm.hpp) $(tools_arma32.def)
tools_arma32.cpp := $(tools)arma32.cpp $(tools_arma32.def) $(tools_arma32.hpp) $(tools_object.hpp) $(tools_utilities.hpp)
tools_arma32assembler.hpp := $(tools)arma32assembler.hpp $(tools_asmassembler.hpp)
tools_arma32assembler.cpp := $(tools)arma32assembler.cpp $(tools_arma32.hpp) $(tools_arma32assembler.hpp) $(tools_utilities.hpp)
tools_arma32disassembler.hpp := $(tools)arma32disassembler.hpp $(tools_asmdisassembler.hpp)
tools_arma32disassembler.cpp := $(tools)arma32disassembler.cpp $(tools_arma32.hpp) $(tools_arma32disassembler.hpp) $(tools_utilities.hpp)
tools_armgenerator.hpp := $(tools)armgenerator.hpp $(tools_asmgenerator.hpp)
tools_armgeneratorcontext.hpp := $(tools)armgeneratorcontext.hpp $(tools_arm.hpp) $(tools_armgenerator.hpp) $(tools_asmgeneratorcontext.hpp)
tools_armgenerator.cpp := $(tools)armgenerator.cpp $(tools_armgeneratorcontext.hpp)
tools_arma32generator.hpp := $(tools)arma32generator.hpp $(tools_arma32assembler.hpp) $(tools_armgenerator.hpp)
tools_arma32generator.cpp := $(tools)arma32generator.cpp $(tools_arma32.hpp) $(tools_arma32generator.hpp) $(tools_armgeneratorcontext.hpp)
tools_arma64.def := $(tools)arma64.def
tools_arma64.hpp := $(tools)arma64.hpp $(tools_arm.hpp) $(tools_arma64.def)
tools_arma64.cpp := $(tools)arma64.cpp $(tools_arma64.def) $(tools_arma64.hpp) $(tools_object.hpp) $(tools_utilities.hpp)
tools_arma64assembler.hpp := $(tools)arma64assembler.hpp $(tools_arma32assembler.hpp)
tools_arma64assembler.cpp := $(tools)arma64assembler.cpp $(tools_arma64.hpp) $(tools_arma64assembler.hpp) $(tools_utilities.hpp)
tools_arma64disassembler.hpp := $(tools)arma64disassembler.hpp $(tools_asmdisassembler.hpp)
tools_arma64disassembler.cpp := $(tools)arma64disassembler.cpp $(tools_arma64.hpp) $(tools_arma64disassembler.hpp) $(tools_utilities.hpp)
tools_arma64generator.hpp := $(tools)arma64generator.hpp $(tools_arma64assembler.hpp) $(tools_asmgenerator.hpp)
tools_arma64generator.cpp := $(tools)arma64generator.cpp $(tools_arma64.hpp) $(tools_arma64generator.hpp) $(tools_asmgeneratorcontext.hpp)
tools_armt32.def := $(tools)armt32.def
tools_armt32.hpp := $(tools)armt32.hpp $(tools_arm.def) $(tools_arm.hpp) $(tools_armt32.def)
tools_armt32.cpp := $(tools)armt32.cpp $(tools_armt32.def) $(tools_armt32.hpp) $(tools_object.hpp) $(tools_utilities.hpp)
tools_armt32assembler.hpp := $(tools)armt32assembler.hpp $(tools_arma32assembler.hpp)
tools_armt32assembler.cpp := $(tools)armt32assembler.cpp $(tools_armt32.hpp) $(tools_armt32assembler.hpp) $(tools_utilities.hpp)
tools_armt32disassembler.hpp := $(tools)armt32disassembler.hpp $(tools_asmdisassembler.hpp)
tools_armt32disassembler.cpp := $(tools)armt32disassembler.cpp $(tools_armt32.hpp) $(tools_armt32disassembler.hpp) $(tools_utilities.hpp)
tools_armt32generator.hpp := $(tools)armt32generator.hpp $(tools_armgenerator.hpp) $(tools_armt32assembler.hpp)
tools_armt32generator.cpp := $(tools)armt32generator.cpp $(tools_armgeneratorcontext.hpp) $(tools_armt32.hpp) $(tools_armt32generator.hpp)
tools_avr.def := $(tools)avr.def
tools_avr.hpp := $(tools)avr.hpp $(tools_avr.def)
tools_avr.cpp := $(tools)avr.cpp $(tools_avr.def) $(tools_avr.hpp) $(tools_object.hpp) $(tools_utilities.hpp)
tools_avrassembler.hpp := $(tools)avrassembler.hpp $(tools_asmassembler.hpp)
tools_avrassembler.cpp := $(tools)avrassembler.cpp $(tools_assembly.hpp) $(tools_avr.hpp) $(tools_avrassembler.hpp) $(tools_format.hpp) $(tools_utilities.hpp)
tools_avrdisassembler.hpp := $(tools)avrdisassembler.hpp $(tools_asmdisassembler.hpp)
tools_avrdisassembler.cpp := $(tools)avrdisassembler.cpp $(tools_avr.hpp) $(tools_avrdisassembler.hpp) $(tools_utilities.hpp)
tools_avrgenerator.hpp := $(tools)avrgenerator.hpp $(tools_asmgenerator.hpp) $(tools_avrassembler.hpp)
tools_avrgenerator.cpp := $(tools)avrgenerator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_avr.hpp) $(tools_avrgenerator.hpp)
tools_avr32.def := $(tools)avr32.def
tools_avr32.hpp := $(tools)avr32.hpp $(tools_avr32.def)
tools_avr32.cpp := $(tools)avr32.cpp $(tools_avr32.def) $(tools_avr32.hpp) $(tools_object.hpp) $(tools_utilities.hpp)
tools_avr32assembler.hpp := $(tools)avr32assembler.hpp $(tools_asmassembler.hpp)
tools_avr32assembler.cpp := $(tools)avr32assembler.cpp $(tools_avr32.hpp) $(tools_avr32assembler.hpp) $(tools_utilities.hpp)
tools_avr32disassembler.hpp := $(tools)avr32disassembler.hpp $(tools_asmdisassembler.hpp)
tools_avr32disassembler.cpp := $(tools)avr32disassembler.cpp $(tools_avr32.hpp) $(tools_avr32disassembler.hpp) $(tools_utilities.hpp)
tools_avr32generator.hpp := $(tools)avr32generator.hpp $(tools_asmgenerator.hpp) $(tools_avr32assembler.hpp)
tools_avr32generator.cpp := $(tools)avr32generator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_avr32.hpp) $(tools_avr32generator.hpp)
tools_m68k.def := $(tools)m68k.def
tools_m68k.hpp := $(tools)m68k.hpp $(tools_m68k.def)
tools_m68k.cpp := $(tools)m68k.cpp $(tools_m68k.def) $(tools_m68k.hpp) $(tools_object.hpp) $(tools_utilities.hpp)
tools_m68kassembler.hpp := $(tools)m68kassembler.hpp $(tools_asmassembler.hpp)
tools_m68kassembler.cpp := $(tools)m68kassembler.cpp $(tools_m68k.hpp) $(tools_m68kassembler.hpp) $(tools_utilities.hpp)
tools_m68kdisassembler.hpp := $(tools)m68kdisassembler.hpp $(tools_asmdisassembler.hpp)
tools_m68kdisassembler.cpp := $(tools)m68kdisassembler.cpp $(tools_m68k.hpp) $(tools_m68kdisassembler.hpp) $(tools_utilities.hpp)
tools_m68kgenerator.hpp := $(tools)m68kgenerator.hpp $(tools_asmgenerator.hpp) $(tools_m68kassembler.hpp)
tools_m68kgenerator.cpp := $(tools)m68kgenerator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_m68k.hpp) $(tools_m68kgenerator.hpp)
tools_mibl.def := $(tools)mibl.def
tools_mibl.hpp := $(tools)mibl.hpp $(tools_mibl.def)
tools_mibl.cpp := $(tools)mibl.cpp $(tools_mibl.def) $(tools_mibl.hpp) $(tools_object.hpp) $(tools_utilities.hpp)
tools_miblassembler.hpp := $(tools)miblassembler.hpp $(tools_asmassembler.hpp)
tools_miblassembler.cpp := $(tools)miblassembler.cpp $(tools_mibl.hpp) $(tools_miblassembler.hpp) $(tools_utilities.hpp)
tools_mibldisassembler.hpp := $(tools)mibldisassembler.hpp $(tools_asmdisassembler.hpp)
tools_mibldisassembler.cpp := $(tools)mibldisassembler.cpp $(tools_mibl.hpp) $(tools_mibldisassembler.hpp) $(tools_utilities.hpp)
tools_miblgenerator.hpp := $(tools)miblgenerator.hpp $(tools_asmgenerator.hpp) $(tools_miblassembler.hpp)
tools_miblgenerator.cpp := $(tools)miblgenerator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_mibl.hpp) $(tools_miblgenerator.hpp)
tools_mips.def := $(tools)mips.def
tools_mips.hpp := $(tools)mips.hpp $(tools_mips.def)
tools_mips.cpp := $(tools)mips.cpp $(tools_mips.def) $(tools_mips.hpp) $(tools_object.hpp) $(tools_utilities.hpp)
tools_mipsassembler.hpp := $(tools)mipsassembler.hpp $(tools_asmassembler.hpp)
tools_mipsassembler.cpp := $(tools)mipsassembler.cpp $(tools_mips.hpp) $(tools_mipsassembler.hpp) $(tools_utilities.hpp)
tools_mipsdisassembler.hpp := $(tools)mipsdisassembler.hpp $(tools_asmdisassembler.hpp)
tools_mipsdisassembler.cpp := $(tools)mipsdisassembler.cpp $(tools_mips.hpp) $(tools_mipsdisassembler.hpp) $(tools_utilities.hpp)
tools_mipsgenerator.hpp := $(tools)mipsgenerator.hpp $(tools_asmgenerator.hpp) $(tools_mipsassembler.hpp)
tools_mipsgenerator.cpp := $(tools)mipsgenerator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_mips.hpp) $(tools_mipsgenerator.hpp)
tools_mmix.def := $(tools)mmix.def
tools_mmix.hpp := $(tools)mmix.hpp $(tools_mmix.def)
tools_mmix.cpp := $(tools)mmix.cpp $(tools_mmix.def) $(tools_mmix.hpp) $(tools_object.hpp) $(tools_utilities.hpp)
tools_mmixassembler.hpp := $(tools)mmixassembler.hpp $(tools_asmassembler.hpp)
tools_mmixassembler.cpp := $(tools)mmixassembler.cpp $(tools_assembly.hpp) $(tools_mmix.def) $(tools_mmix.hpp) $(tools_mmixassembler.hpp) $(tools_utilities.hpp)
tools_mmixdisassembler.hpp := $(tools)mmixdisassembler.hpp $(tools_asmdisassembler.hpp)
tools_mmixdisassembler.cpp := $(tools)mmixdisassembler.cpp $(tools_mmix.hpp) $(tools_mmixdisassembler.hpp) $(tools_utilities.hpp)
tools_mmixgenerator.hpp := $(tools)mmixgenerator.hpp $(tools_asmgenerator.hpp) $(tools_mmixassembler.hpp)
tools_mmixgenerator.cpp := $(tools)mmixgenerator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_ieee.hpp) $(tools_mmix.hpp) $(tools_mmixgenerator.hpp)
tools_or1k.def := $(tools)or1k.def
tools_or1k.hpp := $(tools)or1k.hpp $(tools_or1k.def)
tools_or1k.cpp := $(tools)or1k.cpp $(tools_object.hpp) $(tools_or1k.def) $(tools_or1k.hpp) $(tools_utilities.hpp)
tools_or1kassembler.hpp := $(tools)or1kassembler.hpp $(tools_asmassembler.hpp)
tools_or1kassembler.cpp := $(tools)or1kassembler.cpp $(tools_or1k.hpp) $(tools_or1kassembler.hpp) $(tools_utilities.hpp)
tools_or1kdisassembler.hpp := $(tools)or1kdisassembler.hpp $(tools_asmdisassembler.hpp)
tools_or1kdisassembler.cpp := $(tools)or1kdisassembler.cpp $(tools_or1k.hpp) $(tools_or1kdisassembler.hpp) $(tools_utilities.hpp)
tools_or1kgenerator.hpp := $(tools)or1kgenerator.hpp $(tools_asmgenerator.hpp) $(tools_or1kassembler.hpp)
tools_or1kgenerator.cpp := $(tools)or1kgenerator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_or1k.hpp) $(tools_or1kgenerator.hpp)
tools_ppc.def := $(tools)ppc.def
tools_ppc.hpp := $(tools)ppc.hpp $(tools_ppc.def)
tools_ppc.cpp := $(tools)ppc.cpp $(tools_object.hpp) $(tools_ppc.def) $(tools_ppc.hpp) $(tools_utilities.hpp)
tools_ppcassembler.hpp := $(tools)ppcassembler.hpp $(tools_asmassembler.hpp)
tools_ppcassembler.cpp := $(tools)ppcassembler.cpp $(tools_ppc.hpp) $(tools_ppcassembler.hpp) $(tools_utilities.hpp)
tools_ppcdisassembler.hpp := $(tools)ppcdisassembler.hpp $(tools_asmdisassembler.hpp)
tools_ppcdisassembler.cpp := $(tools)ppcdisassembler.cpp $(tools_ppc.hpp) $(tools_ppcdisassembler.hpp) $(tools_utilities.hpp)
tools_ppcgenerator.hpp := $(tools)ppcgenerator.hpp $(tools_asmgenerator.hpp) $(tools_ppcassembler.hpp)
tools_ppcgenerator.cpp := $(tools)ppcgenerator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_ppc.hpp) $(tools_ppcgenerator.hpp)
tools_risc.def := $(tools)risc.def
tools_risc.hpp := $(tools)risc.hpp $(tools_risc.def)
tools_risc.cpp := $(tools)risc.cpp $(tools_object.hpp) $(tools_risc.def) $(tools_risc.hpp) $(tools_utilities.hpp)
tools_riscassembler.hpp := $(tools)riscassembler.hpp $(tools_asmassembler.hpp)
tools_riscassembler.cpp := $(tools)riscassembler.cpp $(tools_risc.hpp) $(tools_riscassembler.hpp) $(tools_utilities.hpp)
tools_riscdisassembler.hpp := $(tools)riscdisassembler.hpp $(tools_asmdisassembler.hpp)
tools_riscdisassembler.cpp := $(tools)riscdisassembler.cpp $(tools_risc.hpp) $(tools_riscdisassembler.hpp) $(tools_utilities.hpp)
tools_riscgenerator.hpp := $(tools)riscgenerator.hpp $(tools_asmgenerator.hpp) $(tools_riscassembler.hpp)
tools_riscgenerator.cpp := $(tools)riscgenerator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_risc.hpp) $(tools_riscgenerator.hpp)
tools_wasm.def := $(tools)wasm.def
tools_wasm.hpp := $(tools)wasm.hpp $(tools_wasm.def)
tools_wasm.cpp := $(tools)wasm.cpp $(tools_ieee.hpp) $(tools_object.hpp) $(tools_utilities.hpp) $(tools_wasm.def) $(tools_wasm.hpp)
tools_wasmassembler.hpp := $(tools)wasmassembler.hpp $(tools_asmassembler.hpp)
tools_wasmassembler.cpp := $(tools)wasmassembler.cpp $(tools_utilities.hpp) $(tools_wasm.hpp) $(tools_wasmassembler.hpp)
tools_wasmdisassembler.hpp := $(tools)wasmdisassembler.hpp $(tools_asmdisassembler.hpp)
tools_wasmdisassembler.cpp := $(tools)wasmdisassembler.cpp $(tools_utilities.hpp) $(tools_wasm.hpp) $(tools_wasmdisassembler.hpp)
tools_wasmgenerator.hpp := $(tools)wasmgenerator.hpp $(tools_asmgenerator.hpp) $(tools_wasmassembler.hpp)
tools_wasmgenerator.cpp := $(tools)wasmgenerator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_wasm.hpp) $(tools_wasmgenerator.hpp)
tools_xtensa.def := $(tools)xtensa.def
tools_xtensa.hpp := $(tools)xtensa.hpp $(tools_xtensa.def)
tools_xtensa.cpp := $(tools)xtensa.cpp $(tools_object.hpp) $(tools_utilities.hpp) $(tools_xtensa.def) $(tools_xtensa.hpp)
tools_xtensaassembler.hpp := $(tools)xtensaassembler.hpp $(tools_asmassembler.hpp)
tools_xtensaassembler.cpp := $(tools)xtensaassembler.cpp $(tools_utilities.hpp) $(tools_xtensa.hpp) $(tools_xtensaassembler.hpp)
tools_xtensadisassembler.hpp := $(tools)xtensadisassembler.hpp $(tools_asmdisassembler.hpp)
tools_xtensadisassembler.cpp := $(tools)xtensadisassembler.cpp $(tools_utilities.hpp) $(tools_xtensa.hpp) $(tools_xtensadisassembler.hpp)
tools_xtensagenerator.hpp := $(tools)xtensagenerator.hpp $(tools_asmgenerator.hpp) $(tools_xtensaassembler.hpp)
tools_xtensagenerator.cpp := $(tools)xtensagenerator.cpp $(tools_asmgeneratorcontext.hpp) $(tools_xtensa.hpp) $(tools_xtensagenerator.hpp)
tools_preprocessor.cpp := $(tools)preprocessor.cpp $(tools_driver.hpp) $(tools_stdcharset.hpp)
tools_cppprep.drv := $(tools)cppprep.drv $(tools_cpppreprocessor.hpp) $(tools_preprocessor.cpp) $(tools_stringpool.hpp)
tools_printer.cpp := $(tools)printer.cpp $(tools_driver.hpp) $(tools_stdcharset.hpp) $(tools_stdlayout.hpp)
tools_cppprint.drv := $(tools)cppprint.drv $(tools_cppparser.hpp) $(tools_cppprinter.hpp) $(tools_printer.cpp) $(tools_stringpool.hpp)
tools_falprint.drv := $(tools)falprint.drv $(tools_falparser.hpp) $(tools_falprinter.hpp) $(tools_false.hpp) $(tools_printer.cpp)
tools_obprint.drv := $(tools)obprint.drv $(tools_oberon.hpp) $(tools_obparser.hpp) $(tools_obprinter.hpp) $(tools_printer.cpp)
tools_asmprint.drv := $(tools)asmprint.drv $(tools_asmparser.hpp) $(tools_asmprinter.hpp) $(tools_assembly.hpp) $(tools_printer.cpp) $(tools_stringpool.hpp)
tools_checker.cpp := $(tools)checker.cpp $(tools_driver.hpp) $(tools_stdcharset.hpp) $(tools_stdlayout.hpp)
tools_cdcheck.drv := $(tools)cdcheck.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_checker.cpp) $(tools_code.hpp) $(tools_stringpool.hpp)
tools_cppcheck.drv := $(tools)cppcheck.drv $(tools_checker.cpp) $(tools_cppparser.hpp) $(tools_stringpool.hpp)
tools_falcheck.drv := $(tools)falcheck.drv $(tools_checker.cpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_obcheck.drv := $(tools)obcheck.drv $(tools_checker.cpp) $(tools_obchecker.hpp) $(tools_oberon.hpp)
tools_serializer.cpp := $(tools)serializer.cpp $(tools_driver.hpp) $(tools_stdcharset.hpp) $(tools_stdlayout.hpp) $(tools_xml.hpp) $(tools_xmlprinter.hpp)
tools_cppdump.drv := $(tools)cppdump.drv $(tools_cppparser.hpp) $(tools_cppserializer.hpp) $(tools_serializer.cpp) $(tools_stringpool.hpp)
tools_faldump.drv := $(tools)faldump.drv $(tools_falparser.hpp) $(tools_false.hpp) $(tools_falserializer.hpp) $(tools_serializer.cpp)
tools_obdump.drv := $(tools)obdump.drv $(tools_obchecker.hpp) $(tools_oberon.hpp) $(tools_obserializer.hpp) $(tools_serializer.cpp)
tools_stdenvironment.hpp := $(tools)stdenvironment.hpp $(tools_environment.hpp)
tools_interpreter.cpp := $(tools)interpreter.cpp $(tools_driver.hpp) $(tools_stdcharset.hpp) $(tools_stdenvironment.hpp) $(tools_stdlayout.hpp)
tools_cdrun.drv := $(tools)cdrun.drv $(tools_assembly.hpp) $(tools_cdinterpreter.hpp) $(tools_interpreter.cpp) $(tools_stringpool.hpp)
tools_cpprun.drv := $(tools)cpprun.drv $(tools_cppparser.hpp) $(tools_interpreter.cpp) $(tools_stringpool.hpp)
tools_falrun.drv := $(tools)falrun.drv $(tools_falinterpreter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_interpreter.cpp)
tools_obrun.drv := $(tools)obrun.drv $(tools_interpreter.cpp) $(tools_obchecker.hpp) $(tools_oberon.hpp)
tools_transpiler.cpp := $(tools)transpiler.cpp $(tools_driver.hpp) $(tools_stdcharset.hpp) $(tools_stdlayout.hpp)
tools_falcpp.drv := $(tools)falcpp.drv $(tools_falparser.hpp) $(tools_false.hpp) $(tools_faltranspiler.hpp) $(tools_transpiler.cpp)
tools_obcpp.drv := $(tools)obcpp.drv $(tools_obchecker.hpp) $(tools_oberon.hpp) $(tools_obtranspiler.hpp) $(tools_transpiler.cpp) $(tools_utilities.hpp)
tools_generator.cpp := $(tools)generator.cpp $(tools_docchecker.hpp) $(tools_documentation.hpp) $(tools_driver.hpp) $(tools_stdlayout.hpp)
tools_dochtml.drv := $(tools)dochtml.drv $(tools_dochtmlformatter.hpp) $(tools_docparser.hpp) $(tools_generator.cpp)
tools_doclatex.drv := $(tools)doclatex.drv $(tools_doclatexformatter.hpp) $(tools_docparser.hpp) $(tools_generator.cpp)
tools_cppdoc.drv := $(tools)cppdoc.drv $(tools_cppextractor.hpp) $(tools_cppparser.hpp) $(tools_docprinter.hpp) $(tools_generator.cpp) $(tools_stdcharset.hpp) $(tools_stringpool.hpp)
tools_cpphtml.drv := $(tools)cpphtml.drv $(tools_cppextractor.hpp) $(tools_cppparser.hpp) $(tools_dochtmlformatter.hpp) $(tools_generator.cpp) $(tools_stdcharset.hpp) $(tools_stringpool.hpp)
tools_cpplatex.drv := $(tools)cpplatex.drv $(tools_cppextractor.hpp) $(tools_cppparser.hpp) $(tools_doclatexformatter.hpp) $(tools_generator.cpp) $(tools_stdcharset.hpp) $(tools_stringpool.hpp)
tools_obdoc.drv := $(tools)obdoc.drv $(tools_docprinter.hpp) $(tools_generator.cpp) $(tools_obchecker.hpp) $(tools_oberon.hpp) $(tools_obextractor.hpp) $(tools_stdcharset.hpp)
tools_obhtml.drv := $(tools)obhtml.drv $(tools_dochtmlformatter.hpp) $(tools_generator.cpp) $(tools_obchecker.hpp) $(tools_oberon.hpp) $(tools_obextractor.hpp) $(tools_stdcharset.hpp)
tools_oblatex.drv := $(tools)oblatex.drv $(tools_doclatexformatter.hpp) $(tools_generator.cpp) $(tools_obchecker.hpp) $(tools_oberon.hpp) $(tools_obextractor.hpp) $(tools_stdcharset.hpp)
tools_compiler.cpp := $(tools)compiler.cpp $(tools_debug.hpp) $(tools_driver.hpp) $(tools_stdcharset.hpp) $(tools_stringpool.hpp)
tools_cdamd16.drv := $(tools)cdamd16.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp)
tools_cdamd32.drv := $(tools)cdamd32.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp)
tools_cdamd64.drv := $(tools)cdamd64.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp)
tools_cdarma32.drv := $(tools)cdarma32.drv $(tools_arma32generator.hpp) $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp)
tools_cdarma64.drv := $(tools)cdarma64.drv $(tools_arma64generator.hpp) $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp)
tools_cdarmt32.drv := $(tools)cdarmt32.drv $(tools_armt32generator.hpp) $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp)
tools_cdarmt32fpe.drv := $(tools)cdarmt32fpe.drv $(tools_armt32generator.hpp) $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp)
tools_cdavr.drv := $(tools)cdavr.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_avrgenerator.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp)
tools_cdavrxt.drv := $(tools)cdavrxt.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_avrgenerator.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp)
tools_cdavr32.drv := $(tools)cdavr32.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_avr32generator.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp)
tools_cdm68k.drv := $(tools)cdm68k.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_m68kgenerator.hpp)
tools_cdmibl.drv := $(tools)cdmibl.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_miblgenerator.hpp)
tools_cdmips32.drv := $(tools)cdmips32.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_mips.hpp) $(tools_mipsgenerator.hpp) $(tools_utilities.hpp)
tools_cdmips64.drv := $(tools)cdmips64.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_mips.hpp) $(tools_mipsgenerator.hpp) $(tools_utilities.hpp)
tools_cdmmix.drv := $(tools)cdmmix.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_mmixgenerator.hpp)
tools_cdor1k.drv := $(tools)cdor1k.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_or1kgenerator.hpp)
tools_cdppc32.drv := $(tools)cdppc32.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_ppc.hpp) $(tools_ppcgenerator.hpp)
tools_cdppc64.drv := $(tools)cdppc64.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_ppc.hpp) $(tools_ppcgenerator.hpp)
tools_cdrisc.drv := $(tools)cdrisc.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_riscgenerator.hpp)
tools_cdwasm.drv := $(tools)cdwasm.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_wasmgenerator.hpp)
tools_cdxtensa.drv := $(tools)cdxtensa.drv $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_cdchecker.hpp) $(tools_compiler.cpp) $(tools_xtensagenerator.hpp)
tools_cppcode.drv := $(tools)cppcode.drv $(tools_cdgenerator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cppamd16.drv := $(tools)cppamd16.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cppamd32.drv := $(tools)cppamd32.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cppamd64.drv := $(tools)cppamd64.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cpparma32.drv := $(tools)cpparma32.drv $(tools_arma32generator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cpparma64.drv := $(tools)cpparma64.drv $(tools_arma64generator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cpparmt32.drv := $(tools)cpparmt32.drv $(tools_armt32generator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cpparmt32fpe.drv := $(tools)cpparmt32fpe.drv $(tools_armt32generator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cppavr.drv := $(tools)cppavr.drv $(tools_avrgenerator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cppavrxt.drv := $(tools)cppavrxt.drv $(tools_avrgenerator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cppavr32.drv := $(tools)cppavr32.drv $(tools_avr32generator.hpp) $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp)
tools_cppm68k.drv := $(tools)cppm68k.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_m68kgenerator.hpp)
tools_cppmibl.drv := $(tools)cppmibl.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_miblgenerator.hpp)
tools_cppmips32.drv := $(tools)cppmips32.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_mips.hpp) $(tools_mipsgenerator.hpp) $(tools_utilities.hpp)
tools_cppmips64.drv := $(tools)cppmips64.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_mips.hpp) $(tools_mipsgenerator.hpp) $(tools_utilities.hpp)
tools_cppmmix.drv := $(tools)cppmmix.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_mmixgenerator.hpp)
tools_cppor1k.drv := $(tools)cppor1k.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_or1kgenerator.hpp)
tools_cppppc32.drv := $(tools)cppppc32.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_ppc.hpp) $(tools_ppcgenerator.hpp)
tools_cppppc64.drv := $(tools)cppppc64.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_ppc.hpp) $(tools_ppcgenerator.hpp)
tools_cpprisc.drv := $(tools)cpprisc.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_riscgenerator.hpp)
tools_cppwasm.drv := $(tools)cppwasm.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_wasmgenerator.hpp)
tools_cppxtensa.drv := $(tools)cppxtensa.drv $(tools_compiler.cpp) $(tools_cppemitter.hpp) $(tools_cppparser.hpp) $(tools_xtensagenerator.hpp)
tools_falcode.drv := $(tools)falcode.drv $(tools_cdgenerator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falamd16.drv := $(tools)falamd16.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falamd32.drv := $(tools)falamd32.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falamd64.drv := $(tools)falamd64.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falarma32.drv := $(tools)falarma32.drv $(tools_arma32generator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falarma64.drv := $(tools)falarma64.drv $(tools_arma64generator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falarmt32.drv := $(tools)falarmt32.drv $(tools_armt32generator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falarmt32fpe.drv := $(tools)falarmt32fpe.drv $(tools_armt32generator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falavr.drv := $(tools)falavr.drv $(tools_avrgenerator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falavrxt.drv := $(tools)falavrxt.drv $(tools_avrgenerator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falavr32.drv := $(tools)falavr32.drv $(tools_avr32generator.hpp) $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp)
tools_falm68k.drv := $(tools)falm68k.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_m68kgenerator.hpp)
tools_falmibl.drv := $(tools)falmibl.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_miblgenerator.hpp)
tools_falmips32.drv := $(tools)falmips32.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_mips.hpp) $(tools_mipsgenerator.hpp) $(tools_utilities.hpp)
tools_falmips64.drv := $(tools)falmips64.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_mips.hpp) $(tools_mipsgenerator.hpp) $(tools_utilities.hpp)
tools_falmmix.drv := $(tools)falmmix.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_mmixgenerator.hpp)
tools_falor1k.drv := $(tools)falor1k.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_or1kgenerator.hpp)
tools_falppc32.drv := $(tools)falppc32.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_ppc.hpp) $(tools_ppcgenerator.hpp)
tools_falppc64.drv := $(tools)falppc64.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_ppc.hpp) $(tools_ppcgenerator.hpp)
tools_falrisc.drv := $(tools)falrisc.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_riscgenerator.hpp)
tools_falwasm.drv := $(tools)falwasm.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_wasmgenerator.hpp)
tools_falxtensa.drv := $(tools)falxtensa.drv $(tools_compiler.cpp) $(tools_falemitter.hpp) $(tools_falparser.hpp) $(tools_false.hpp) $(tools_xtensagenerator.hpp)
tools_obcode.drv := $(tools)obcode.drv $(tools_cdgenerator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obamd16.drv := $(tools)obamd16.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obamd32.drv := $(tools)obamd32.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obamd64.drv := $(tools)obamd64.drv $(tools_amd64.hpp) $(tools_amd64generator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obarma32.drv := $(tools)obarma32.drv $(tools_arma32generator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obarma64.drv := $(tools)obarma64.drv $(tools_arma64generator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obarmt32.drv := $(tools)obarmt32.drv $(tools_armt32generator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obarmt32fpe.drv := $(tools)obarmt32fpe.drv $(tools_armt32generator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obavr.drv := $(tools)obavr.drv $(tools_avrgenerator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obavrxt.drv := $(tools)obavrxt.drv $(tools_avrgenerator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obavr32.drv := $(tools)obavr32.drv $(tools_avr32generator.hpp) $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obm68k.drv := $(tools)obm68k.drv $(tools_compiler.cpp) $(tools_m68kgenerator.hpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obmibl.drv := $(tools)obmibl.drv $(tools_compiler.cpp) $(tools_miblgenerator.hpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obmips32.drv := $(tools)obmips32.drv $(tools_compiler.cpp) $(tools_mips.hpp) $(tools_mipsgenerator.hpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp) $(tools_utilities.hpp)
tools_obmips64.drv := $(tools)obmips64.drv $(tools_compiler.cpp) $(tools_mips.hpp) $(tools_mipsgenerator.hpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp) $(tools_utilities.hpp)
tools_obmmix.drv := $(tools)obmmix.drv $(tools_compiler.cpp) $(tools_mmixgenerator.hpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp)
tools_obor1k.drv := $(tools)obor1k.drv $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp) $(tools_or1kgenerator.hpp)
tools_obppc32.drv := $(tools)obppc32.drv $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp) $(tools_ppc.hpp) $(tools_ppcgenerator.hpp)
tools_obppc64.drv := $(tools)obppc64.drv $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp) $(tools_ppc.hpp) $(tools_ppcgenerator.hpp)
tools_obrisc.drv := $(tools)obrisc.drv $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp) $(tools_riscgenerator.hpp)
tools_obwasm.drv := $(tools)obwasm.drv $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp) $(tools_wasmgenerator.hpp)
tools_obxtensa.drv := $(tools)obxtensa.drv $(tools_compiler.cpp) $(tools_obchecker.hpp) $(tools_obemitter.hpp) $(tools_oberon.hpp) $(tools_xtensagenerator.hpp)
tools_converter.cpp := $(tools)converter.cpp $(tools_debug.hpp) $(tools_driver.hpp) $(tools_object.hpp) $(tools_stdcharset.hpp)
tools_dbgdwarf.drv := $(tools)dbgdwarf.drv $(tools_converter.cpp) $(tools_dbgdwarfconverter.hpp)
tools_assembler.cpp := $(tools)assembler.cpp $(tools_asmparser.hpp) $(tools_assembly.hpp) $(tools_driver.hpp) $(tools_stdcharset.hpp) $(tools_stringpool.hpp)
tools_amd16asm.drv := $(tools)amd16asm.drv $(tools_amd64.hpp) $(tools_amd64assembler.hpp) $(tools_assembler.cpp)
tools_amd32asm.drv := $(tools)amd32asm.drv $(tools_amd64.hpp) $(tools_amd64assembler.hpp) $(tools_assembler.cpp)
tools_amd64asm.drv := $(tools)amd64asm.drv $(tools_amd64.hpp) $(tools_amd64assembler.hpp) $(tools_assembler.cpp)
tools_arma32asm.drv := $(tools)arma32asm.drv $(tools_arma32assembler.hpp) $(tools_assembler.cpp)
tools_arma64asm.drv := $(tools)arma64asm.drv $(tools_arma64assembler.hpp) $(tools_assembler.cpp)
tools_armt32asm.drv := $(tools)armt32asm.drv $(tools_armt32assembler.hpp) $(tools_assembler.cpp)
tools_avrasm.drv := $(tools)avrasm.drv $(tools_assembler.cpp) $(tools_avrassembler.hpp)
tools_avr32asm.drv := $(tools)avr32asm.drv $(tools_assembler.cpp) $(tools_avr32assembler.hpp)
tools_m68kasm.drv := $(tools)m68kasm.drv $(tools_assembler.cpp) $(tools_m68kassembler.hpp)
tools_miblasm.drv := $(tools)miblasm.drv $(tools_assembler.cpp) $(tools_miblassembler.hpp)
tools_mips32asm.drv := $(tools)mips32asm.drv $(tools_assembler.cpp) $(tools_mips.hpp) $(tools_mipsassembler.hpp) $(tools_utilities.hpp)
tools_mips64asm.drv := $(tools)mips64asm.drv $(tools_assembler.cpp) $(tools_mips.hpp) $(tools_mipsassembler.hpp) $(tools_utilities.hpp)
tools_mmixasm.drv := $(tools)mmixasm.drv $(tools_assembler.cpp) $(tools_mmixassembler.hpp)
tools_or1kasm.drv := $(tools)or1kasm.drv $(tools_assembler.cpp) $(tools_or1kassembler.hpp)
tools_ppc32asm.drv := $(tools)ppc32asm.drv $(tools_assembler.cpp) $(tools_ppc.hpp) $(tools_ppcassembler.hpp)
tools_ppc64asm.drv := $(tools)ppc64asm.drv $(tools_assembler.cpp) $(tools_ppc.hpp) $(tools_ppcassembler.hpp)
tools_riscasm.drv := $(tools)riscasm.drv $(tools_assembler.cpp) $(tools_riscassembler.hpp)
tools_wasmasm.drv := $(tools)wasmasm.drv $(tools_assembler.cpp) $(tools_wasmassembler.hpp)
tools_xtensaasm.drv := $(tools)xtensaasm.drv $(tools_assembler.cpp) $(tools_xtensaassembler.hpp)
tools_disassembler.cpp := $(tools)disassembler.cpp $(tools_driver.hpp) $(tools_object.hpp) $(tools_stdcharset.hpp)
tools_amd16dism.drv := $(tools)amd16dism.drv $(tools_amd64.hpp) $(tools_amd64disassembler.hpp) $(tools_disassembler.cpp)
tools_amd32dism.drv := $(tools)amd32dism.drv $(tools_amd64.hpp) $(tools_amd64disassembler.hpp) $(tools_disassembler.cpp)
tools_amd64dism.drv := $(tools)amd64dism.drv $(tools_amd64.hpp) $(tools_amd64disassembler.hpp) $(tools_disassembler.cpp)
tools_arma32dism.drv := $(tools)arma32dism.drv $(tools_arma32disassembler.hpp) $(tools_disassembler.cpp)
tools_arma64dism.drv := $(tools)arma64dism.drv $(tools_arma64disassembler.hpp) $(tools_disassembler.cpp)
tools_armt32dism.drv := $(tools)armt32dism.drv $(tools_armt32disassembler.hpp) $(tools_disassembler.cpp)
tools_avrdism.drv := $(tools)avrdism.drv $(tools_avrdisassembler.hpp) $(tools_disassembler.cpp)
tools_avr32dism.drv := $(tools)avr32dism.drv $(tools_avr32disassembler.hpp) $(tools_disassembler.cpp)
tools_m68kdism.drv := $(tools)m68kdism.drv $(tools_disassembler.cpp) $(tools_m68kdisassembler.hpp)
tools_mibldism.drv := $(tools)mibldism.drv $(tools_disassembler.cpp) $(tools_mibldisassembler.hpp)
tools_mips32dism.drv := $(tools)mips32dism.drv $(tools_disassembler.cpp) $(tools_mips.hpp) $(tools_mipsdisassembler.hpp) $(tools_utilities.hpp)
tools_mips64dism.drv := $(tools)mips64dism.drv $(tools_disassembler.cpp) $(tools_mips.hpp) $(tools_mipsdisassembler.hpp) $(tools_utilities.hpp)
tools_mmixdism.drv := $(tools)mmixdism.drv $(tools_disassembler.cpp) $(tools_mmixdisassembler.hpp)
tools_or1kdism.drv := $(tools)or1kdism.drv $(tools_disassembler.cpp) $(tools_or1kdisassembler.hpp)
tools_ppc32dism.drv := $(tools)ppc32dism.drv $(tools_disassembler.cpp) $(tools_ppc.hpp) $(tools_ppcdisassembler.hpp)
tools_ppc64dism.drv := $(tools)ppc64dism.drv $(tools_disassembler.cpp) $(tools_ppc.hpp) $(tools_ppcdisassembler.hpp)
tools_riscdism.drv := $(tools)riscdism.drv $(tools_disassembler.cpp) $(tools_riscdisassembler.hpp)
tools_wasmdism.drv := $(tools)wasmdism.drv $(tools_disassembler.cpp) $(tools_wasmdisassembler.hpp)
tools_xtensadism.drv := $(tools)xtensadism.drv $(tools_disassembler.cpp) $(tools_xtensadisassembler.hpp)
tools_linker.cpp := $(tools)linker.cpp $(tools_driver.hpp) $(tools_objlinker.hpp) $(tools_stdcharset.hpp) $(tools_utilities.hpp)
tools_linklib.drv := $(tools)linklib.drv $(tools_linker.cpp)
tools_linkbin.drv := $(tools)linkbin.drv $(tools_linker.cpp)
tools_linkmem.drv := $(tools)linkmem.drv $(tools_linker.cpp)
tools_linkhex.drv := $(tools)linkhex.drv $(tools_linker.cpp) $(tools_objhexfile.hpp)
tools_linkprg.drv := $(tools)linkprg.drv $(tools_linker.cpp)
utilities_ansi.hpp := $(utilities)ansi.hpp
utilities_ansi.cpp := $(utilities)ansi.cpp $(utilities_ansi.hpp)
utilities_system.hpp := $(utilities)system.hpp
utilities_darwin.cpp := $(utilities)darwin.cpp $(utilities_system.hpp)
utilities_depwalk.cpp := $(utilities)depwalk.cpp
utilities_ecsd.cpp := $(utilities)ecsd.cpp $(utilities_system.hpp)
utilities_freebsd.cpp := $(utilities)freebsd.cpp $(utilities_system.hpp)
utilities_hexdump.cpp := $(utilities)hexdump.cpp $(utilities_system.hpp)
utilities_linecheck.cpp := $(utilities)linecheck.cpp
utilities_linux.cpp := $(utilities)linux.cpp $(utilities_system.hpp)
utilities_posix.cpp := $(utilities)posix.cpp $(utilities_ansi.hpp) $(utilities_system.hpp)
utilities_regtest.cpp := $(utilities)regtest.cpp $(utilities_system.hpp)
utilities_windows.cpp := $(utilities)windows.cpp $(utilities_system.hpp)
cpplibrary_initializer_list := $(cpplibrary)initializer_list
cpplibrary_algorithm := $(cpplibrary)algorithm $(cpplibrary_initializer_list)
cpplibrary_any := $(cpplibrary)any
cpplibrary_array := $(cpplibrary)array $(cpplibrary_initializer_list)
cpplibrary_cassert := $(cpplibrary)cassert
cpplibrary_assert.h := $(cpplibrary)assert.h $(cpplibrary_cassert)
cpplibrary_atomic := $(cpplibrary)atomic
cpplibrary_barrier := $(cpplibrary)barrier
cpplibrary_bit := $(cpplibrary)bit
cpplibrary_iosfwd := $(cpplibrary)iosfwd
cpplibrary_string := $(cpplibrary)string $(cpplibrary_initializer_list)
cpplibrary_bitset := $(cpplibrary)bitset $(cpplibrary_iosfwd) $(cpplibrary_string)
cpplibrary_cctype := $(cpplibrary)cctype
cpplibrary_cerrno := $(cpplibrary)cerrno
cpplibrary_cfenv := $(cpplibrary)cfenv
cpplibrary_cfloat := $(cpplibrary)cfloat
cpplibrary_charconv := $(cpplibrary)charconv
cpplibrary_chrono := $(cpplibrary)chrono
cpplibrary_cinttypes := $(cpplibrary)cinttypes
cpplibrary_climits := $(cpplibrary)climits
cpplibrary_clocale := $(cpplibrary)clocale
cpplibrary_cmath := $(cpplibrary)cmath
cpplibrary_codecvt := $(cpplibrary)codecvt
cpplibrary_compare := $(cpplibrary)compare
cpplibrary_complex := $(cpplibrary)complex
cpplibrary_complex.h := $(cpplibrary)complex.h
cpplibrary_concepts := $(cpplibrary)concepts
cpplibrary_condition_variable := $(cpplibrary)condition_variable
cpplibrary_coroutine := $(cpplibrary)coroutine
cpplibrary_csetjmp := $(cpplibrary)csetjmp
cpplibrary_csignal := $(cpplibrary)csignal
cpplibrary_cstdarg := $(cpplibrary)cstdarg
cpplibrary_cstddef := $(cpplibrary)cstddef
cpplibrary_cstdint := $(cpplibrary)cstdint
cpplibrary_cstdio := $(cpplibrary)cstdio
cpplibrary_cstdlib := $(cpplibrary)cstdlib
cpplibrary_cstring := $(cpplibrary)cstring
cpplibrary_ctime := $(cpplibrary)ctime
cpplibrary_ctype.h := $(cpplibrary)ctype.h $(cpplibrary_cctype)
cpplibrary_cuchar := $(cpplibrary)cuchar
cpplibrary_cwchar := $(cpplibrary)cwchar
cpplibrary_cwctype := $(cpplibrary)cwctype
cpplibrary_debugging := $(cpplibrary)debugging
cpplibrary_deque := $(cpplibrary)deque $(cpplibrary_initializer_list)
cpplibrary_errno.h := $(cpplibrary)errno.h $(cpplibrary_cerrno)
cpplibrary_exception := $(cpplibrary)exception
cpplibrary_execution := $(cpplibrary)execution
cpplibrary_expected := $(cpplibrary)expected
cpplibrary_fenv.h := $(cpplibrary)fenv.h $(cpplibrary_cfenv)
cpplibrary_filesystem := $(cpplibrary)filesystem
cpplibrary_flat_map := $(cpplibrary)flat_map
cpplibrary_flat_set := $(cpplibrary)flat_set
cpplibrary_float.h := $(cpplibrary)float.h $(cpplibrary_cfloat)
cpplibrary_format := $(cpplibrary)format
cpplibrary_forward_list := $(cpplibrary)forward_list $(cpplibrary_initializer_list)
cpplibrary_fstream := $(cpplibrary)fstream
cpplibrary_functional := $(cpplibrary)functional
cpplibrary_future := $(cpplibrary)future
cpplibrary_generator := $(cpplibrary)generator
cpplibrary_inttypes.h := $(cpplibrary)inttypes.h $(cpplibrary_cinttypes)
cpplibrary_iomanip := $(cpplibrary)iomanip
cpplibrary_ios := $(cpplibrary)ios $(cpplibrary_iosfwd)
cpplibrary_istream := $(cpplibrary)istream $(cpplibrary_iosfwd)
cpplibrary_ostream := $(cpplibrary)ostream $(cpplibrary_iosfwd)
cpplibrary_streambuf := $(cpplibrary)streambuf
cpplibrary_iostream := $(cpplibrary)iostream $(cpplibrary_ios) $(cpplibrary_istream) $(cpplibrary_ostream) $(cpplibrary_streambuf)
cpplibrary_iso646.h := $(cpplibrary)iso646.h
cpplibrary_iterator := $(cpplibrary)iterator
cpplibrary_latch := $(cpplibrary)latch
cpplibrary_limits := $(cpplibrary)limits
cpplibrary_limits.h := $(cpplibrary)limits.h $(cpplibrary_climits)
cpplibrary_list := $(cpplibrary)list $(cpplibrary_initializer_list)
cpplibrary_locale := $(cpplibrary)locale
cpplibrary_locale.h := $(cpplibrary)locale.h $(cpplibrary_clocale)
cpplibrary_map := $(cpplibrary)map $(cpplibrary_initializer_list)
cpplibrary_math.h := $(cpplibrary)math.h $(cpplibrary_cmath)
cpplibrary_mdspan := $(cpplibrary)mdspan
cpplibrary_memory := $(cpplibrary)memory
cpplibrary_memory_resource := $(cpplibrary)memory_resource
cpplibrary_mutex := $(cpplibrary)mutex
cpplibrary_new := $(cpplibrary)new
cpplibrary_numbers := $(cpplibrary)numbers
cpplibrary_numeric := $(cpplibrary)numeric
cpplibrary_optional := $(cpplibrary)optional
cpplibrary_print := $(cpplibrary)print
cpplibrary_queue := $(cpplibrary)queue $(cpplibrary_initializer_list)
cpplibrary_random := $(cpplibrary)random $(cpplibrary_initializer_list)
cpplibrary_ranges := $(cpplibrary)ranges
cpplibrary_ratio := $(cpplibrary)ratio
cpplibrary_rcu := $(cpplibrary)rcu
cpplibrary_regex := $(cpplibrary)regex $(cpplibrary_initializer_list)
cpplibrary_scoped_allocator := $(cpplibrary)scoped_allocator
cpplibrary_semaphore := $(cpplibrary)semaphore
cpplibrary_set := $(cpplibrary)set $(cpplibrary_initializer_list)
cpplibrary_setjmp.h := $(cpplibrary)setjmp.h $(cpplibrary_csetjmp)
cpplibrary_shared_mutex := $(cpplibrary)shared_mutex
cpplibrary_signal.h := $(cpplibrary)signal.h $(cpplibrary_csignal)
cpplibrary_source_location := $(cpplibrary)source_location
cpplibrary_span := $(cpplibrary)span
cpplibrary_spanstream := $(cpplibrary)spanstream
cpplibrary_sstream := $(cpplibrary)sstream
cpplibrary_stack := $(cpplibrary)stack $(cpplibrary_initializer_list)
cpplibrary_stacktrace := $(cpplibrary)stacktrace
cpplibrary_stdalign.h := $(cpplibrary)stdalign.h
cpplibrary_stdarg.h := $(cpplibrary)stdarg.h $(cpplibrary_cstdarg)
cpplibrary_stdatomic.h := $(cpplibrary)stdatomic.h
cpplibrary_stdbool.h := $(cpplibrary)stdbool.h
cpplibrary_stddef.h := $(cpplibrary)stddef.h $(cpplibrary_cstddef)
cpplibrary_stdexcept := $(cpplibrary)stdexcept
cpplibrary_stdfloat := $(cpplibrary)stdfloat
cpplibrary_stdint.h := $(cpplibrary)stdint.h $(cpplibrary_cstdint)
cpplibrary_stdio.h := $(cpplibrary)stdio.h $(cpplibrary_cstdio)
cpplibrary_stdlib.h := $(cpplibrary)stdlib.h $(cpplibrary_cstdlib)
cpplibrary_stop_token := $(cpplibrary)stop_token
cpplibrary_string.h := $(cpplibrary)string.h $(cpplibrary_cstring)
cpplibrary_string_view := $(cpplibrary)string_view
cpplibrary_strstream := $(cpplibrary)strstream
cpplibrary_syncstream := $(cpplibrary)syncstream
cpplibrary_system_error := $(cpplibrary)system_error $(cpplibrary_cerrno)
cpplibrary_text_encoding := $(cpplibrary)text_encoding
cpplibrary_tgmath.h := $(cpplibrary)tgmath.h $(cpplibrary_cmath) $(cpplibrary_complex)
cpplibrary_thread := $(cpplibrary)thread
cpplibrary_time.h := $(cpplibrary)time.h $(cpplibrary_ctime)
cpplibrary_tuple := $(cpplibrary)tuple
cpplibrary_type_traits := $(cpplibrary)type_traits
cpplibrary_typeindex := $(cpplibrary)typeindex
cpplibrary_typeinfo := $(cpplibrary)typeinfo
cpplibrary_uchar.h := $(cpplibrary)uchar.h $(cpplibrary_cuchar)
cpplibrary_unordered_map := $(cpplibrary)unordered_map $(cpplibrary_initializer_list)
cpplibrary_unordered_set := $(cpplibrary)unordered_set $(cpplibrary_initializer_list)
cpplibrary_utility := $(cpplibrary)utility $(cpplibrary_initializer_list)
cpplibrary_valarray := $(cpplibrary)valarray $(cpplibrary_initializer_list)
cpplibrary_variant := $(cpplibrary)variant
cpplibrary_vector := $(cpplibrary)vector $(cpplibrary_initializer_list)
cpplibrary_version := $(cpplibrary)version
cpplibrary_wchar.h := $(cpplibrary)wchar.h $(cpplibrary_cwchar)
cpplibrary_wctype.h := $(cpplibrary)wctype.h $(cpplibrary_cwctype)
cpplibrary_cassert.cpp := $(cpplibrary)cassert.cpp $(cpplibrary_cassert) $(cpplibrary_cstdio) $(cpplibrary_cstdlib)
cpplibrary_cctype.cpp := $(cpplibrary)cctype.cpp $(cpplibrary_cctype)
cpplibrary_cmath.cpp := $(cpplibrary)cmath.cpp $(cpplibrary_cmath)
cpplibrary_csetjmp.cpp := $(cpplibrary)csetjmp.cpp $(cpplibrary_csetjmp)
cpplibrary_cstdio.cpp := $(cpplibrary)cstdio.cpp $(cpplibrary_cstdio)
cpplibrary_cstdlib.cpp := $(cpplibrary)cstdlib.cpp $(cpplibrary_cstdlib) $(cpplibrary_cstring)
cpplibrary_cstring.cpp := $(cpplibrary)cstring.cpp $(cpplibrary_cstring)
cpplibrary_ctime.cpp := $(cpplibrary)ctime.cpp $(cpplibrary_ctime)
cpplibrary_debugging.cpp := $(cpplibrary)debugging.cpp $(cpplibrary_debugging)
cpplibrary_exception.cpp := $(cpplibrary)exception.cpp $(cpplibrary_cstdlib) $(cpplibrary_exception)
deflibrary_assembly := $(deflibrary)assembly
deflibrary_macho := $(deflibrary)macho $(deflibrary_assembly)
deflibrary_darwinlib := $(deflibrary)darwinlib $(deflibrary_macho)
deflibrary_elf := $(deflibrary)elf $(deflibrary_assembly)
deflibrary_linuxlib := $(deflibrary)linuxlib $(deflibrary_elf)
deflibrary_pe := $(deflibrary)pe $(deflibrary_assembly)
deflibrary_tos := $(deflibrary)tos $(deflibrary_assembly)
deflibrary_wasm := $(deflibrary)wasm $(deflibrary_assembly)
deflibrary_wasmlib := $(deflibrary)wasmlib $(deflibrary_wasm)
deflibrary_winlib := $(deflibrary)winlib $(deflibrary_pe)
apilibrary_darwin.hpp := $(apilibrary)darwin.hpp $(cpplibrary_cstddef) $(cpplibrary_cstdint)
apilibrary_dlfcn.h := $(apilibrary)dlfcn.h
apilibrary_linux.hpp := $(apilibrary)linux.hpp $(cpplibrary_cstddef) $(cpplibrary_cstdint)
apilibrary_pthread.h := $(apilibrary)pthread.h $(cpplibrary_cstddef)
apilibrary_SDL.h := $(apilibrary)SDL.h $(cpplibrary_cstdint)
apilibrary_tos.h := $(apilibrary)tos.h
apilibrary_windows.h := $(apilibrary)windows.h
runtime_atmegarun.cpp := $(runtime)atmegarun.cpp $(deflibrary_assembly)
runtime_runtime.cpp := $(runtime)runtime.cpp $(cpplibrary_cctype) $(cpplibrary_cmath) $(cpplibrary_cstdio) $(cpplibrary_cstdlib) $(cpplibrary_cstring)
runtime_cpprunrun.cpp := $(runtime)cpprunrun.cpp $(cpplibrary_cassert.cpp) $(cpplibrary_cctype.cpp) $(cpplibrary_cmath.cpp) $(cpplibrary_csetjmp.cpp) $(cpplibrary_cstdio.cpp) $(cpplibrary_cstdlib.cpp) $(cpplibrary_cstring.cpp) $(cpplibrary_ctime.cpp) $(cpplibrary_debugging.cpp) $(cpplibrary_exception.cpp) $(runtime_runtime.cpp)
runtime_darwinrun.cpp := $(runtime)darwinrun.cpp $(apilibrary_darwin.hpp) $(cpplibrary_cstdio) $(cpplibrary_cstdlib) $(deflibrary_macho)
apilibrary_efi.h := $(apilibrary)efi.h $(cpplibrary_cstdint) $(cpplibrary_cstdlib)
deflibrary_efi := $(deflibrary)efi $(deflibrary_assembly)
runtime_efirun.cpp := $(runtime)efirun.cpp $(apilibrary_efi.h) $(cpplibrary_cstdio) $(cpplibrary_cstdlib) $(deflibrary_efi) $(deflibrary_pe)
runtime_efiapi.cpp := $(runtime)efiapi.cpp $(deflibrary_efi)
runtime_libdl.cpp := $(runtime)libdl.cpp $(deflibrary_linuxlib)
runtime_libpthread.cpp := $(runtime)libpthread.cpp $(deflibrary_linuxlib)
runtime_sdl.cpp := $(runtime)sdl.cpp
runtime_libsdl.cpp := $(runtime)libsdl.cpp $(deflibrary_linuxlib) $(runtime_sdl.cpp)
runtime_linuxrun.cpp := $(runtime)linuxrun.cpp $(apilibrary_linux.hpp) $(cpplibrary_cstdio) $(cpplibrary_cstdlib) $(cpplibrary_ctime) $(deflibrary_elf)
runtime_tosapi.cpp := $(runtime)tosapi.cpp $(deflibrary_tos)
runtime_tosrun.cpp := $(runtime)tosrun.cpp $(apilibrary_tos.h) $(cpplibrary_cstdio) $(cpplibrary_cstdlib) $(deflibrary_tos)
runtime_webassemblyrun.cpp := $(runtime)webassemblyrun.cpp $(cpplibrary_cstdlib) $(deflibrary_wasm)
runtime_winapi.cpp := $(runtime)winapi.cpp $(deflibrary_winlib)
runtime_winrun.cpp := $(runtime)winrun.cpp $(apilibrary_windows.h) $(cpplibrary_cstdio) $(cpplibrary_cstdlib) $(cpplibrary_ctime) $(cpplibrary_debugging) $(deflibrary_winlib)
runtime_winsdl.cpp := $(runtime)winsdl.cpp $(deflibrary_winlib) $(runtime_sdl.cpp)
oblibrary_obl.arguments.mod := $(oblibrary)obl.arguments.mod
oblibrary_obl.hashes.mod := $(oblibrary)obl.hashes.mod
oblibrary_obl.basictypes.mod := $(oblibrary)obl.basictypes.mod $(oblibrary_obl.hashes.mod)
oblibrary_obl.booleans.mod := $(oblibrary)obl.booleans.mod
oblibrary_obl.characters.mod := $(oblibrary)obl.characters.mod
oblibrary_obl.devices.mod := $(oblibrary)obl.devices.mod
oblibrary_obl.environment.mod := $(oblibrary)obl.environment.mod
oblibrary_obl.exceptions.mod := $(oblibrary)obl.exceptions.mod
oblibrary_obl.files.mod := $(oblibrary)obl.files.mod $(oblibrary_obl.devices.mod)
oblibrary_obl.iostreams.mod := $(oblibrary)obl.iostreams.mod $(oblibrary_obl.files.mod)
oblibrary_obl.streams.mod := $(oblibrary)obl.streams.mod
oblibrary_obl.iterators.mod := $(oblibrary)obl.iterators.mod
oblibrary_obl.arrays.mod := $(oblibrary)obl.arrays.mod $(oblibrary_obl.iterators.mod)
oblibrary_obl.coroutines.mod := $(oblibrary)obl.coroutines.mod $(oblibrary_obl.exceptions.mod)
oblibrary_obl.dynamicarrays.mod := $(oblibrary)obl.dynamicarrays.mod $(oblibrary_obl.arrays.mod) $(oblibrary_obl.exceptions.mod) $(oblibrary_obl.iterators.mod)
oblibrary_obl.generators.mod := $(oblibrary)obl.generators.mod $(oblibrary_obl.coroutines.mod)
oblibrary_obl.lists.mod := $(oblibrary)obl.lists.mod $(oblibrary_obl.exceptions.mod) $(oblibrary_obl.iterators.mod)
oblibrary_obl.pairs.mod := $(oblibrary)obl.pairs.mod
oblibrary_obl.hashmaps.mod := $(oblibrary)obl.hashmaps.mod $(oblibrary_obl.lists.mod) $(oblibrary_obl.pairs.mod)
oblibrary_obl.functions.mod := $(oblibrary)obl.functions.mod $(oblibrary_obl.generators.mod) $(oblibrary_obl.iterators.mod)
oblibrary_obl.in.mod := $(oblibrary)obl.in.mod
oblibrary_obl.math.mod := $(oblibrary)obl.math.mod
oblibrary_obl.out.mod := $(oblibrary)obl.out.mod $(oblibrary_obl.math.mod)
oblibrary_obl.random.mod := $(oblibrary)obl.random.mod
oblibrary_obl.sets.mod := $(oblibrary)obl.sets.mod
oblibrary_obl.strings.mod := $(oblibrary)obl.strings.mod
oblibrary_obl.trees.mod := $(oblibrary)obl.trees.mod $(oblibrary_obl.exceptions.mod) $(oblibrary_obl.iterators.mod)
oblibrary_api.darwin.mod := $(oblibrary)api.darwin.mod
oblibrary_api.linux.mod := $(oblibrary)api.linux.mod
oblibrary_api.pthread.mod := $(oblibrary)api.pthread.mod
oblibrary_api.sdl.mod := $(oblibrary)api.sdl.mod
oblibrary_api.tos.mod := $(oblibrary)api.tos.mod
oblibrary_api.windows.mod := $(oblibrary)api.windows.mod
oblibrary_coroutines.mod := $(oblibrary)coroutines.mod $(oblibrary_obl.coroutines.mod)
oblibrary_in.mod := $(oblibrary)in.mod
oblibrary_math.mod := $(oblibrary)math.mod $(oblibrary_obl.math.mod)
oblibrary_mathc.mod := $(oblibrary)mathc.mod $(oblibrary_obl.math.mod)
oblibrary_mathl.mod := $(oblibrary)mathl.mod $(oblibrary_obl.math.mod)
oblibrary_mathlc.mod := $(oblibrary)mathlc.mod $(oblibrary_obl.math.mod)
oblibrary_out.mod := $(oblibrary)out.mod
oblibrary_strings.mod := $(oblibrary)strings.mod $(oblibrary_obl.strings.mod)
oblibrary_xyplane.mod := $(oblibrary)xyplane.mod $(oblibrary_api.sdl.mod)

# tools & utilities

bin := $(addprefix $(tools), $(addsuffix $(prg), mapplace mapsearch docprint doccheck cdopt \
	$(preprocessors) $(printers) $(checkers) $(serializers) $(interpreters) $(transpilers) $(generators) $(compilers) $(converters) $(assemblers) $(disassemblers) $(linkers))) \
	$(addprefix $(utilities), $(addsuffix $(prg), depwalk ecsd hexdump linecheck regtest))
tls := $(addprefix $(tools), object.cpp objlinker.cpp objmap.cpp objhexfile.cpp mapplace.cpp mapsearch.cpp debug.cpp dbgconverter.cpp dbgdwarfconverter.cpp \
	documentation.cpp doclexer.cpp docparser.cpp docprinter.cpp docprint.cpp docchecker.cpp doccheck.cpp docextractor.cpp dochtmlformatter.cpp doclatexformatter.cpp \
	code.cpp cdchecker.cpp cdoptimizer.cpp cdopt.cpp cdinterpreter.cpp cdemitter.cpp cdgenerator.cpp xml.cpp xmlprinter.cpp xmlserializer.cpp \
	cpp.cpp cpplexer.cpp cpppreprocessor.cpp cppparser.cpp cppprinter.cpp cppchecker.cpp cppserializer.cpp cppinterpreter.cpp cppextractor.cpp cppemitter.cpp \
	false.cpp fallexer.cpp falparser.cpp falprinter.cpp falserializer.cpp falinterpreter.cpp faltranspiler.cpp falemitter.cpp \
	oberon.cpp oblexer.cpp obparser.cpp obprinter.cpp obchecker.cpp obserializer.cpp obinterpreter.cpp obtranspiler.cpp obextractor.cpp obemitter.cpp \
	assembly.cpp asmlexer.cpp asmparser.cpp asmprinter.cpp asmchecker.cpp asmassembler.cpp asmdisassembler.cpp asmgenerator.cpp \
	amd64.cpp amd64assembler.cpp amd64disassembler.cpp amd64generator.cpp arm.cpp arma32.cpp arma32assembler.cpp arma32disassembler.cpp armgenerator.cpp arma32generator.cpp \
	arma64.cpp arma64assembler.cpp arma64disassembler.cpp arma64generator.cpp armt32.cpp armt32assembler.cpp armt32disassembler.cpp armt32generator.cpp \
	avr.cpp avrassembler.cpp avrdisassembler.cpp avrgenerator.cpp avr32.cpp avr32assembler.cpp avr32disassembler.cpp avr32generator.cpp \
	m68k.cpp m68kassembler.cpp m68kdisassembler.cpp m68kgenerator.cpp mibl.cpp miblassembler.cpp mibldisassembler.cpp miblgenerator.cpp \
	mips.cpp mipsassembler.cpp mipsdisassembler.cpp mipsgenerator.cpp mmix.cpp mmixassembler.cpp mmixdisassembler.cpp mmixgenerator.cpp \
	or1k.cpp or1kassembler.cpp or1kdisassembler.cpp or1kgenerator.cpp ppc.cpp ppcassembler.cpp ppcdisassembler.cpp ppcgenerator.cpp \
	risc.cpp riscassembler.cpp riscdisassembler.cpp riscgenerator.cpp wasm.cpp wasmassembler.cpp wasmdisassembler.cpp wasmgenerator.cpp \
	xtensa.cpp xtensaassembler.cpp xtensadisassembler.cpp xtensagenerator.cpp)
drv := $(addprefix $(tools), $(addsuffix .drv, $(preprocessors) $(printers) $(checkers) $(serializers) $(interpreters) $(transpilers) $(generators) $(compilers) $(converters) $(assemblers) $(disassemblers) $(linkers)))
uts := $(addprefix $(utilities), ansi.cpp darwin.cpp depwalk.cpp ecsd.cpp freebsd.cpp hexdump.cpp linecheck.cpp linux.cpp posix.cpp regtest.cpp windows.cpp)
obj := $(tls:.cpp=$(o)) $(drv:.drv=$(o)) $(uts:.cpp=$(o))

$(addprefix $(tools), linkhex$(prg): $(addsuffix $(o), objhexfile))
$(addprefix $(tools), mapplace$(prg): $(addsuffix $(o), object objmap))
$(addprefix $(tools), mapsearch$(prg): $(addsuffix $(o), object objmap))
$(addprefix $(tools), docprint$(prg): $(addsuffix $(o), documentation doclexer docparser docprinter))
$(addprefix $(tools), doccheck$(prg): $(addsuffix $(o), documentation doclexer docparser docchecker))
$(addprefix $(tools), cdcheck$(prg): $(addsuffix $(o), object code cdchecker assembly asmlexer asmparser asmchecker))
$(addprefix $(tools), cdopt$(prg): $(addsuffix $(o), object code cdchecker cdoptimizer cdgenerator assembly asmlexer asmparser asmchecker))
$(addprefix $(tools), cdrun$(prg): $(addsuffix $(o), object code cdchecker cdinterpreter assembly asmlexer asmparser asmchecker))
$(addprefix $(tools), cppprep$(prg): $(addsuffix $(o), cpplexer cpppreprocessor))
$(addprefix $(tools), cppprint$(prg): $(addsuffix $(o), cpp cpplexer cpppreprocessor cppparser cppprinter cppchecker cppinterpreter))
$(addprefix $(tools), cppcheck$(prg): $(addsuffix $(o), cpp cpplexer cpppreprocessor cppparser cppprinter cppchecker cppinterpreter))
$(addprefix $(tools), cppdump$(prg): $(addsuffix $(o), cpp cpplexer cpppreprocessor cppparser cppprinter cppchecker cppinterpreter cppserializer))
$(addprefix $(tools), cpprun$(prg): $(addsuffix $(o), cpp cpplexer cpppreprocessor cppparser cppprinter cppchecker cppinterpreter))
$(addprefix $(tools), falprint$(prg): $(addsuffix $(o), false fallexer falparser falprinter))
$(addprefix $(tools), falcheck$(prg): $(addsuffix $(o), false fallexer falparser))
$(addprefix $(tools), faldump$(prg): $(addsuffix $(o), false fallexer falparser falserializer))
$(addprefix $(tools), falrun$(prg): $(addsuffix $(o), false fallexer falparser falinterpreter))
$(addprefix $(tools), falcpp$(prg): $(addsuffix $(o), false fallexer falparser faltranspiler))
$(addprefix $(tools), obprint$(prg): $(addsuffix $(o), oberon oblexer obparser obprinter))
$(addprefix $(tools), obcheck$(prg): $(addsuffix $(o), oberon oblexer obparser obprinter obchecker obinterpreter))
$(addprefix $(tools), obdump$(prg): $(addsuffix $(o), oberon oblexer obparser obprinter obchecker obinterpreter obserializer))
$(addprefix $(tools), obrun$(prg): $(addsuffix $(o), oberon oblexer obparser obprinter obchecker obinterpreter))
$(addprefix $(tools), obcpp$(prg): $(addsuffix $(o), oberon oblexer obparser obprinter obchecker obinterpreter obtranspiler))
$(addprefix $(tools), asmprint$(prg): $(addsuffix $(o), object assembly asmlexer asmparser asmprinter))
$(addprefix $(tools), $(addsuffix $(prg), $(serializers)): $(addsuffix $(o), xml xmlprinter xmlserializer))
$(addprefix $(tools), $(addsuffix $(prg), $(filter cpp%, $(generators))): $(addsuffix $(o), cpp cpplexer cpppreprocessor cppparser cppprinter cppchecker cppinterpreter cppextractor docextractor))
$(addprefix $(tools), $(addsuffix $(prg), $(filter ob%, $(generators))): $(addsuffix $(o), oberon oblexer obparser obprinter obchecker obinterpreter obextractor docextractor))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %doc, $(generators))): $(addsuffix $(o), docprinter))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %html, $(generators))): $(addsuffix $(o), dochtmlformatter))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %latex, $(generators))): $(addsuffix $(o), doclatexformatter))
$(addprefix $(tools), $(addsuffix $(prg), $(generators)): $(addsuffix $(o), documentation doclexer docparser docchecker))
$(addprefix $(tools), $(addsuffix $(prg), $(filter cd%, $(compilers))): $(addsuffix $(o), cdchecker))
$(addprefix $(tools), $(addsuffix $(prg), $(filter cpp%, $(compilers))): $(addsuffix $(o), cpp cpplexer cpppreprocessor cppparser cppprinter cppchecker cppinterpreter cppemitter cdemitter))
$(addprefix $(tools), $(addsuffix $(prg), $(filter fa%, $(compilers))): $(addsuffix $(o), false fallexer falparser falemitter cdemitter))
$(addprefix $(tools), $(addsuffix $(prg), $(filter ob%, $(compilers))): $(addsuffix $(o), oberon oblexer obparser obprinter obchecker obinterpreter obemitter cdemitter))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %code, $(compilers))): $(addsuffix $(o), cdgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %amd16 %amd32 %amd64, $(compilers))): $(addsuffix $(o), amd64 amd64assembler amd64generator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %arma32, $(compilers))): $(addsuffix $(o), arm arma32 arma32assembler armgenerator arma32generator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %arma64, $(compilers))): $(addsuffix $(o), arm arma32 arma32assembler arma64 arma64assembler arma64generator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %armt32 %armt32fpe, $(compilers))): $(addsuffix $(o), arm arma32 arma32assembler armt32 armt32assembler armgenerator armt32generator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %avr %avrxt, $(compilers))): $(addsuffix $(o), avr avrassembler avrgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %avr32, $(compilers))): $(addsuffix $(o), avr32 avr32assembler avr32generator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %m68k, $(compilers))): $(addsuffix $(o), m68k m68kassembler m68kgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %mibl, $(compilers))): $(addsuffix $(o), mibl miblassembler miblgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %mips32 %mips64, $(compilers))): $(addsuffix $(o), mips mipsassembler mipsgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %mmix, $(compilers))): $(addsuffix $(o), mmix mmixassembler mmixgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %or1k, $(compilers))): $(addsuffix $(o), or1k or1kassembler or1kgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %ppc32 %ppc64, $(compilers))): $(addsuffix $(o), ppc ppcassembler ppcgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %risc, $(compilers))): $(addsuffix $(o), risc riscassembler riscgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %wasm, $(compilers))): $(addsuffix $(o), wasm wasmassembler wasmgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %xtensa, $(compilers))): $(addsuffix $(o), xtensa xtensaassembler xtensagenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(filter-out %code, $(compilers))): $(addsuffix $(o), asmprinter asmassembler asmgenerator))
$(addprefix $(tools), $(addsuffix $(prg), $(compilers)): $(addsuffix $(o), object debug code cdchecker assembly asmlexer asmparser asmchecker))
$(addprefix $(tools), $(addsuffix $(prg), $(filter %dwarf, $(converters))): $(addsuffix $(o), dbgdwarfconverter))
$(addprefix $(tools), $(addsuffix $(prg), $(converters)): $(addsuffix $(o), object debug dbgconverter asmlexer))
$(addprefix $(tools), $(addsuffix $(prg), amd16asm amd32asm amd64asm): $(addsuffix $(o), amd64 amd64assembler))
$(addprefix $(tools), $(addsuffix $(prg), arma32asm): $(addsuffix $(o), arm arma32 arma32assembler))
$(addprefix $(tools), $(addsuffix $(prg), arma64asm): $(addsuffix $(o), arm arma32 arma32assembler arma64 arma64assembler))
$(addprefix $(tools), $(addsuffix $(prg), armt32asm): $(addsuffix $(o), arm arma32 arma32assembler armt32 armt32assembler))
$(addprefix $(tools), $(addsuffix $(prg), avrasm): $(addsuffix $(o), avr avrassembler))
$(addprefix $(tools), $(addsuffix $(prg), avr32asm): $(addsuffix $(o), avr32 avr32assembler))
$(addprefix $(tools), $(addsuffix $(prg), m68kasm): $(addsuffix $(o), m68k m68kassembler))
$(addprefix $(tools), $(addsuffix $(prg), miblasm): $(addsuffix $(o), mibl miblassembler))
$(addprefix $(tools), $(addsuffix $(prg), mips32asm mips64asm): $(addsuffix $(o), mips mipsassembler))
$(addprefix $(tools), $(addsuffix $(prg), mmixasm): $(addsuffix $(o), mmix mmixassembler))
$(addprefix $(tools), $(addsuffix $(prg), or1kasm): $(addsuffix $(o), or1k or1kassembler))
$(addprefix $(tools), $(addsuffix $(prg), ppc32asm ppc64asm): $(addsuffix $(o), ppc ppcassembler))
$(addprefix $(tools), $(addsuffix $(prg), riscasm): $(addsuffix $(o), risc riscassembler))
$(addprefix $(tools), $(addsuffix $(prg), wasmasm): $(addsuffix $(o), wasm wasmassembler))
$(addprefix $(tools), $(addsuffix $(prg), xtensaasm): $(addsuffix $(o), xtensa xtensaassembler))
$(addprefix $(tools), $(addsuffix $(prg), $(assemblers)): $(addsuffix $(o), object assembly asmlexer asmparser asmchecker asmassembler))
$(addprefix $(tools), $(addsuffix $(prg), amd16dism amd32dism amd64dism): $(addsuffix $(o), amd64 amd64disassembler))
$(addprefix $(tools), $(addsuffix $(prg), arma32dism): $(addsuffix $(o), arm arma32 arma32disassembler))
$(addprefix $(tools), $(addsuffix $(prg), arma64dism): $(addsuffix $(o), arm arma32 arma64 arma64disassembler))
$(addprefix $(tools), $(addsuffix $(prg), armt32dism): $(addsuffix $(o), arm arma32 armt32 armt32disassembler))
$(addprefix $(tools), $(addsuffix $(prg), avrdism): $(addsuffix $(o), avr avrdisassembler))
$(addprefix $(tools), $(addsuffix $(prg), avr32dism): $(addsuffix $(o), avr32 avr32disassembler))
$(addprefix $(tools), $(addsuffix $(prg), m68kdism): $(addsuffix $(o), m68k m68kdisassembler))
$(addprefix $(tools), $(addsuffix $(prg), mibldism): $(addsuffix $(o), mibl mibldisassembler))
$(addprefix $(tools), $(addsuffix $(prg), mips32dism mips64dism): $(addsuffix $(o), mips mipsdisassembler))
$(addprefix $(tools), $(addsuffix $(prg), mmixdism): $(addsuffix $(o), mmix mmixdisassembler))
$(addprefix $(tools), $(addsuffix $(prg), or1kdism): $(addsuffix $(o), or1k or1kdisassembler))
$(addprefix $(tools), $(addsuffix $(prg), ppc32dism ppc64dism): $(addsuffix $(o), ppc ppcdisassembler))
$(addprefix $(tools), $(addsuffix $(prg), riscdism): $(addsuffix $(o), risc riscdisassembler))
$(addprefix $(tools), $(addsuffix $(prg), wasmdism): $(addsuffix $(o), wasm wasmdisassembler))
$(addprefix $(tools), $(addsuffix $(prg), xtensadism): $(addsuffix $(o), xtensa xtensadisassembler))
$(addprefix $(tools), $(addsuffix $(prg), $(disassemblers)): $(addsuffix $(o), object asmlexer asmdisassembler))
$(addprefix $(tools), $(addsuffix $(prg), $(linkers)): $(addsuffix $(o), object objmap objlinker))
$(addprefix $(utilities), $(addsuffix $(prg), ecsd hexdump regtest): $(addsuffix $(o), $(basename $(environment))))

$(addprefix $(tools), $(addsuffix .drv, $(preprocessors)): preprocessor.cpp)
	$(file > $@,// $(basename $(notdir $@)) preprocessor driver)
	$(file >> $@,#define $(call lookup, $(basename $@), language, name)LANGUAGE)
	$(file >> $@,#include "preprocessor.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(printers)): printer.cpp)
	$(file > $@, // $(basename $(notdir $@)) pretty printer driver)
	$(file >> $@,#define $(call lookup, $(basename $@), language, name)LANGUAGE)
	$(file >> $@,#include "printer.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(checkers)): checker.cpp)
	$(file > $@,// $(basename $(notdir $@)) semantic checker driver)
	$(file >> $@,#define $(call lookup, $(basename $@), language, name)LANGUAGE)
	$(file >> $@,#include "checker.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(serializers)): serializer.cpp)
	$(file > $@, // $(basename $(notdir $@)) serializer driver)
	$(file >> $@,#define $(call lookup, $(basename $@), language, name)LANGUAGE)
	$(file >> $@,#include "serializer.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(interpreters)): interpreter.cpp)
	$(file > $@,// $(basename $(notdir $@)) interpreter driver)
	$(file >> $@,#define $(call lookup, $(basename $@), language, name)LANGUAGE)
	$(file >> $@,#include "interpreter.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(transpilers)): transpiler.cpp)
	$(file > $@,// $(basename $(notdir $@)) transpiler driver)
	$(file >> $@,#define $(call lookup, $(basename $@), language, name)LANGUAGE)
	$(file >> $@,#include "transpiler.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(generators)): generator.cpp)
	$(file > $@,// $(basename $(notdir $@)) documentation generator driver)
	$(file >> $@,#define $(call lookup, $(basename $@), extractor, name)EXTRACTOR)
	$(file >> $@,#define $(call lookup, $(basename $@), formatter, name)FORMATTER)
	$(file >> $@,#include "generator.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(compilers)): compiler.cpp) ;
	$(file > $@,// $(basename $(notdir $@)) compiler driver)
	$(file >> $@,#define $(call lookup, $(basename $@), frontend, name)FRONTEND)
	$(file >> $@,#define $(call lookup, $(basename $@), backend, name)BACKEND)
	$(file >> $@,#$(if $(filter $(toolsp)%.drv, $@),undef,define) CODEOPTIMIZER)
	$(file >> $@,#$(if $(filter $(tools)fal%.drv $(toolsp)%code.drv, $@),undef,define) ASSEMBLYLISTING)
	$(file >> $@,#$(if $(filter $(tools)fal%.drv $(toolsp)%code.drv, $@),undef,define) DEBUGGINGINFORMATION)
	$(file >> $@,#include "compiler.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(converters)): converter.cpp)
	$(file > $@,// $(basename $(notdir $@)) converter driver)
	$(file >> $@,#define $(call lookup, $(basename $@), debugfileformat, name)DEBUGFILEFORMAT)
	$(file >> $@,#include "converter.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(assemblers)): assembler.cpp)
	$(file > $@,// $(basename $(notdir $@)) assembler driver)
	$(file >> $@,#define $(call lookup, $(basename $@), architecture, name)ARCHITECTURE)
	$(file >> $@,#include "assembler.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(disassemblers)): disassembler.cpp)
	$(file > $@,// $(basename $(notdir $@)) disassembler driver)
	$(file >> $@,#define $(call lookup, $(basename $@), architecture, name)ARCHITECTURE)
	$(file >> $@,#include "disassembler.cpp")
	@cd $(curr)

$(addprefix $(tools), $(addsuffix .drv, $(linkers)): linker.cpp)
	$(file > $@,// $(basename $(notdir $@)) linker driver)
	$(file >> $@,#define $(call lookup, $(basename $@), linkfileformat, name)LINKFILEFORMAT)
	$(file >> $@,#include "linker.cpp")
	@cd $(curr)

$(foreach file, $(tls), $(eval $(file:.cpp=$(o)): $(tools_$(notdir $(file)))))
$(foreach file, $(drv), $(eval $(file:.drv=$(o)): $(tools_$(notdir $(file)))))
$(foreach file, $(uts), $(eval $(file:.cpp=$(o)): $(utilities_$(notdir $(file)))))

$(tls:.cpp=$(o)) $(uts:.cpp=$(o)): %$(o):
	@cd $(dir $<) && $(cc) $(cflags) $(notdir $<)

$(drv:.drv=$(o)): %$(o): %.drv
	@cd $(dir $<) && $(cc) $(cflags) $(notdir $<)

$(bin): %$(prg): %$(o)
	@cd $(dir $<) && $(ld) $(lflags) $(notdir $^)

tools: $(filter $(toolsp)%, $(bin))
utilities: $(filter $(utilitiesp)%, $(bin))

# runtime

export ECSDEFINE :=
export ECSINCLUDE := $(call path,$(abspath $(cpplibrary))/)

cpp := $(addprefix $(runtime), atmegarun.cpp cpprunrun.cpp darwinrun.cpp efirun.cpp efiapi.cpp libdl.cpp libpthread.cpp libsdl.cpp linuxrun.cpp runtime.cpp sdl.cpp tosapi.cpp tosrun.cpp webassemblyrun.cpp winapi.cpp winrun.cpp winsdl.cpp)
asm := $(addprefix $(runtime), at32uc3a3run.asm avrremote.asm avrsimrun.asm bios16run.asm bios32run.asm bios64run.asm dosrun.asm mmixsimrun.asm or1ksimrun.asm riscdiskrun.asm rpi2brun.asm)
run := $(addprefix $(runtime), $(addsuffix run.obf, $(targets)) tosrun.obf tosapi.obf webassemblyrun.obf $(foreach prefix, $(filter atmega% axtmega%, $(environments)), $(addprefix $(prefix), run.obf)) $(foreach prefix, $(filter %darwin, $(environments)), $(addprefix $(prefix), run.obf)) $(foreach prefix, $(filter efi%, $(environments)), $(addprefix $(prefix), run.obf api.obf)) $(foreach prefix, $(patsubst %linux, %, $(filter %linux, $(environments))), $(addprefix $(prefix), linuxrun.obf libdl.obf libpthread.obf libsdl.obf)) $(foreach prefix, $(filter win%, $(environments)), $(addprefix $(prefix), run.obf api.obf sdl.obf)))
lib := $(addprefix $(runtime), $(addsuffix run.lib, $(addprefix cpp, $(targets)) $(addprefix ob, $(targets))))
std := $(addprefix $(cpplibrary), cassert.cpp cctype.cpp cmath.cpp csetjmp.cpp cstdio.cpp cstdlib.cpp cstring.cpp ctime.cpp debugging.cpp exception.cpp)
hdr := $(addprefix $(cpplibrary), algorithm any array assert.h atomic barrier bit bitset cassert cctype cerrno cfenv cfloat charconv chrono cinttypes climits clocale cmath codecvt compare complex complex.h concepts condition_variable coroutine csetjmp csignal cstdarg cstddef cstdint cstdio cstdlib cstring ctime ctype.h cuchar cwchar cwctype debugging deque errno.h exception execution expected fenv.h filesystem flat_map flat_set float.h format forward_list fstream functional future generator initializer_list inttypes.h iomanip ios iosfwd iostream iso646.h istream iterator latch limits limits.h list locale locale.h map math.h mdspan memory memory_resource mutex new numbers numeric optional ostream print queue random ranges ratio rcu regex scoped_allocator semaphore set setjmp.h shared_mutex signal.h source_location span spanstream sstream stack stacktrace stdalign.h stdarg.h stdatomic.h stdbool.h stddef.h stdexcept stdfloat stdint.h stdio.h stdlib.h stop_token streambuf string string.h string_view strstream syncstream system_error text_encoding tgmath.h thread time.h tuple type_traits typeindex typeinfo uchar.h unordered_map unordered_set utility valarray variant vector version wchar.h wctype.h)
api := $(addprefix $(apilibrary), darwin.hpp dlfcn.h linux.hpp pthread.h SDL.h tos.h windows.h)
def := $(addprefix $(deflibrary), assembly darwinlib elf linuxlib macho pe tos wasm wasmlib winlib)
obl := $(addprefix $(oblibrary), obl.arguments.mod obl.hashes.mod obl.basictypes.mod obl.booleans.mod obl.characters.mod obl.devices.mod obl.environment.mod obl.exceptions.mod obl.files.mod obl.iostreams.mod obl.streams.mod obl.iterators.mod obl.arrays.mod obl.coroutines.mod obl.dynamicarrays.mod obl.generators.mod obl.lists.mod obl.pairs.mod obl.hashmaps.mod obl.functions.mod obl.in.mod obl.math.mod obl.out.mod obl.random.mod obl.sets.mod obl.strings.mod obl.trees.mod)
ext := $(addprefix $(oblibrary), api.darwin.mod api.linux.mod api.pthread.mod api.sdl.mod api.tos.mod api.windows.mod)
oak := $(addprefix $(oblibrary), coroutines.mod in.mod math.mod mathc.mod mathl.mod mathlc.mod out.mod strings.mod xyplane.mod)
cod := $(addprefix $(runtime), coderun.cod cppcoderun.cod obcoderun.cod)
mod := $(obl) $(ext) $(oak)
obf := $(asm:.asm=.obf)
sym := $(mod:.mod=.sym)

$(addprefix $(runtime), at32uc3a3run.obf): $(tools)avr32asm$(prg)
$(addprefix $(runtime), avrremote.obf avrsimrun.obf): $(tools)avrasm$(prg)
$(addprefix $(runtime), bios16run.obf dosrun.obf): $(tools)amd16asm$(prg)
$(addprefix $(runtime), bios32run.obf): $(tools)amd32asm$(prg)
$(addprefix $(runtime), bios64run.obf): $(tools)amd64asm$(prg)
$(addprefix $(runtime), mmixsimrun.obf): $(tools)mmixasm$(prg)
$(addprefix $(runtime), or1ksimrun.obf): $(tools)or1kasm$(prg)
$(addprefix $(runtime), riscdiskrun.obf): $(tools)riscasm$(prg)
$(addprefix $(runtime), rpi2brun.obf): $(tools)arma32asm$(prg)

$(targets:%=$(runtimep)%run.obf): $(runtimep)%run.obf: $(tools)cpp%$(prg) $(runtime_runtime.cpp)
$(runtime)tosrun.obf: $(tools)cppm68k$(prg) $(runtime_tosrun.cpp)
$(runtime)tosapi.obf: $(tools)cppm68k$(prg) $(runtime_tosapi.cpp)
$(runtime)webassemblyrun.obf: $(tools)cppwasm$(prg) $(runtime_webassemblyrun.cpp)
$(filter $(runtime)atmega%.obf, $(run)): $(tools)cppavr$(prg) $(runtime_atmegarun.cpp)
$(filter $(runtime)axtmega%.obf, $(run)): $(tools)cppavrxt$(prg) $(runtime_atmegarun.cpp)
$(filter $(runtimep)%darwinrun.obf, $(run)): $(runtimep)%darwinrun.obf: $(tools)cpp%$(prg) $(runtime_darwinrun.cpp)
$(filter $(runtimep)%linuxrun.obf, $(run)): $(runtimep)%linuxrun.obf: $(tools)cpp%$(prg) $(runtime_linuxrun.cpp)
$(filter $(runtimep)%libdl.obf, $(run)): $(runtimep)%libdl.obf: $(tools)cpp%$(prg) $(runtime_libdl.cpp)
$(filter $(runtimep)%libpthread.obf, $(run)): $(runtimep)%libpthread.obf: $(tools)cpp%$(prg) $(runtime_libpthread.cpp)
$(filter $(runtimep)%libsdl.obf, $(run)): $(runtimep)%libsdl.obf: $(tools)cpp%$(prg) $(runtime_libsdl.cpp)
$(filter $(runtime)efi%run.obf, $(run)): $(runtime)efi%run.obf: $(tools)cppamd%$(prg) $(runtime_efirun.cpp)
$(filter $(runtime)efi%api.obf, $(run)): $(runtime)efi%api.obf: $(tools)cppamd%$(prg) $(runtime_efiapi.cpp)
$(filter $(runtime)win%run.obf, $(run)): $(runtime)win%run.obf: $(tools)cppamd%$(prg) $(runtime_winrun.cpp)
$(filter $(runtime)win%api.obf, $(run)): $(runtime)win%api.obf: $(tools)cppamd%$(prg) $(runtime_winapi.cpp)
$(filter $(runtime)win%sdl.obf, $(run)): $(runtime)win%sdl.obf: $(tools)cppamd%$(prg) $(runtime_winsdl.cpp)

$(targets:%=$(runtime)cpp%run.lib): $(runtime)cpp%run.lib: $(tools)cpp%$(prg)
$(targets:%=$(runtime)ob%run.lib): $(runtime)ob%run.lib: $(tools)ob%$(prg)

$(runtime)coderun.cod: $(tools)cppcode$(prg) $(runtime_runtime.cpp)
$(runtime)cppcoderun.cod: $(tools)cppcode$(prg)
$(runtime)obcoderun.cod: $(tools)obcode$(prg)

$(targets:%=$(runtime)cpp%run.lib) $(runtime)cppcoderun.cod: $(std) $(hdr)
$(targets:%=$(runtime)ob%run.lib) $(runtime)obcoderun.cod: $(mod)

$(foreach file, $(sym), $(eval $(file): $(filter-out $(file), $(oblibrary_$(notdir $(file:.sym=.mod)):.mod=.sym))))

$(obf): %.obf: %.asm
	@cd $(runtime) && $(prev)$(word 2, $^) $(notdir $(word 1, $^))

$(run): %.obf: | %.dbg
	@cd $| && $(eval export ECSDEFINE=__$(notdir $*)__) $(prev)$(prev)$(word 1, $^) $(prev)$(notdir $(word 2, $^)) && $(mv) $(notdir $(word 2, $(^:.cpp=.obf))) $(prev)$(notdir $@)

$(lib): %.lib: $(tools)linklib$(prg) | %.dbg
	@cd $| && $(prev)$(prev)$(word 2, $^) $(addprefix $(prev)$(prev), $(filter %.cpp %.mod, $^)) && $(prev)$(prev)$(word 1, $^) $(addsuffix .obf, $(basename $(notdir $(filter %.cpp %.mod, $^)))) && $(mv) $(basename $(notdir $(lastword $(filter %.cpp %.mod, $^)))).lib $(prev)$(notdir $@)

$(cod): %.cod: $(tools)asmprint$(prg) | %.dbg
	@cd $| && $(prev)$(prev)$(word 2, $^) $(addprefix $(prev)$(prev), $(filter %.cpp %.mod, $^)) && $(prev)$(prev)$(word 1, $^) $(addsuffix .cod, $(basename $(notdir $(filter %.cpp %.mod, $^)))) > $(prev)$(notdir $@)

$(run:.obf=.dbg) $(lib:.lib=.dbg) $(cod:.cod=.dbg): %.dbg:
	@cd $(runtime) && $(md) $(notdir $@)

$(sym): %.sym: %.mod $(tools)obcheck$(prg)
	@cd $(oblibrary) && $(prev)$(prev)$(tools)obcheck$(prg) $(notdir $<)

runtime: $(obf) $(run) $(lib) $(cod) $(sym)

# documentation

tex := $(addprefix $(documentation), manual.tex guide.tex cpp.tex false.tex oberon.tex assembly.tex amd64.tex arm.tex avr.tex avr32.tex m68k.tex mibl.tex mips.tex mmix.tex or1k.tex ppc.tex risc.tex wasm.tex xtensa.tex documentation.tex debug.tex code.tex object.tex material.tex overview.tex implementation.tex)
set := $(addprefix $(documentation), amd64.set arm.set arma32.set arma64.set avr.set avr32.set m68k.set mibl.set mips.set mmix.set or1k.set ppc.set risc.set wasm.set xtensa.set code.set)
doc := $(addprefix $(documentation), cpplibrary.doc oblibrary.doc oaklibrary.doc)
aux := $(foreach document, $(tex), $(addprefix $(document:.tex=), .aux .bbl .blg .lof .log .lot .nav .out .snm .tmb .toc .upa .upb .vrb))
idx := $(foreach index, environment library manual runtime tools, $(addprefix $(documentation)$(index), .idx .ilg .ind))
pdf := $(tex:.tex=.pdf)

$(documentation)cpplibrary.doc: $(tools)cpplatex$(prg) $(std)
	@cd $(cpplibrary) && $(prev)$(prev)$(tools)cpplatex$(prg) $(notdir $(std))
	@$(mv) $(lastword $(std:.cpp=.tex)) $@

$(documentation)oblibrary.doc: $(tools)obcheck$(prg) $(tools)oblatex$(prg) $(obl)
	@cd $(oblibrary) && $(prev)$(prev)$(tools)obcheck$(prg) $(notdir $(obl)) && $(prev)$(prev)$(tools)oblatex$(prg) $(notdir $(sort $(obl)))
	@$(mv) $(lastword $(sort $(obl:.mod=.tex))) $@

$(documentation)oaklibrary.doc: $(tools)obcheck$(prg) $(tools)oblatex$(prg) $(ext) $(oak)
	@cd $(oblibrary) && $(prev)$(prev)$(tools)obcheck$(prg) $(notdir $(ext) $(oak)) && $(prev)$(prev)$(tools)oblatex$(prg) $(notdir $(sort $(oak)))
	@$(mv) $(lastword $(sort $(oak:.mod=.tex))) $@

$(set): $(documentationp)%.set: $(documentationp)%.tab $(toolsp)%.def $(tools)cppprep$(prg)
	@$(tools)cppprep$(prg) $< > $@

$(pdf): $(documentationp)%.pdf: $(documentationp)%.tex $(documentation)utilities.tex $(documentation)references.bib
	@cd $(documentation) && pdflatex -interaction batchmode -no-shell-escape -file-line-error -halt-on-error -draftmode $(basename $(notdir $<)) > $(nul)
	@$(if $(filter $(basename $(notdir $<)), manual), cd $(documentation) && makeindex -q $(basename $(notdir $<)) && makeindex -q tools && makeindex -q library && makeindex -q runtime && makeindex -q environment)
	@cd $(documentation) && bibtex $(basename $(notdir $<)) > $(nul)
	@cd $(documentation) && pdflatex -interaction batchmode -no-shell-escape -file-line-error -halt-on-error -draftmode $(basename $(notdir $<)) > $(nul)
	@cd $(documentation) && pdflatex -interaction batchmode -no-shell-escape -file-line-error -halt-on-error $(basename $(notdir $<)) > $(nul)

$(filter $(set:.set=.pdf), $(pdf)): %.pdf: %.set
$(addprefix $(documentation), cpp.pdf): $(documentation)cpplibrary.doc
$(addprefix $(documentation), oberon.pdf): $(documentation)oblibrary.doc $(documentation)oaklibrary.doc
$(addprefix $(documentation), assembly.pdf): $(set)
$(addprefix $(documentation), arm.pdf): $(addprefix $(documentation), arma32.set arma64.set)
$(addprefix $(documentation), manual.pdf material.pdf): $(addprefix $(documentation), overview.pdf implementation.pdf)
$(addprefix $(documentation), manual.pdf): $(doc) $(set) $(tex) $(addprefix $(documentation), introduction.tex interface.tex tools.tex extensions.tex faq.tex gpl.tex rse.tex fdl.tex)

documentation: $(pdf)

# tests

export ECSIMPORT := $(call path,$(abspath $(tests))/)

testenvironments := $(filter-out at32uc3a3 bios% efi% riscdisk rpi2b tos, $(environments))
asmarchitectures := $(filter-out amd16 amd32 mips32 ppc32, $(architectures))
tst := $(addprefix $(tests), $(addprefix link, lib bin) $(addprefix doc, check printcheck) \
	$(addprefix cd, check printcheck optcheck run printrun optrun $(testenvironments)) \
	$(addprefix cpp, cppcheck cpprun check printcheck dump run printrun code $(testenvironments)) \
	$(addprefix fal, check printcheck dump run printrun cppcheck cpprun code $(testenvironments)) \
	$(addprefix ob, check printcheck dump run printrun cppcheck cpprun code $(testenvironments)) \
	$(foreach architecture, $(asmarchitectures), $(addprefix $(architecture), asm printasm)))
res := $(addsuffix .res, $(tst))

test = @cd $(tests) && $(prev)$(utilities)regtest$(prg) $1 $(notdir $@.$2 $@.res $(filter %.tst, $^)) && $(tc) $(notdir $@)

$(tst): $(utilities)regtest$(prg)

.PHONY: $(tests)linkage
$(tests)linkage: $(addprefix $(tests)link, lib bin)

$(addprefix $(tests)link, lib bin): $(tests)link%: $(tests)link%.tst $(tools)link%$(prg)
	$(call test,"$(abspath $(tools)link$*$(prg)) link$*.obf",obf)

.PHONY: $(tests)documentation
$(tests)documentation: $(addprefix $(tests)doc, check printcheck)

$(addprefix $(tests)doc, check printcheck): $(tests)doccheck.tst

$(tests)doccheck: $(tools)doccheck$(prg)
	$(call test,"$(abspath $(tools)doccheck$(prg)) doccheck.doc",doc)

$(tests)docprintcheck: $(tools)docprint$(prg) $(tools)doccheck$(prg)
	$(call test,"$(abspath $(tools)docprint$(prg)) docprintcheck.doc > docprintcheck.out && $(abspath $(tools)doccheck$(prg)) docprintcheck.out",doc)

.PHONY: $(tests)code
$(tests)code: $(addprefix $(tests)cd, check printcheck run printrun $(hostenvironments))

$(addprefix $(tests)cd, check printcheck optcheck): $(tests)assembly.tst $(tests)cdcheck.tst
$(addprefix $(tests)cd, run printrun optrun $(testenvironments)): $(tests)cdrun.tst

$(tests)cdcheck: $(tools)cdcheck$(prg)
	$(call test,"$(abspath $(tools)cdcheck$(prg)) cdcheck.cod",cod)

$(tests)cdprintcheck: $(tools)asmprint$(prg) $(tools)cdcheck$(prg)
	$(call test,"$(abspath $(tools)asmprint$(prg)) cdprintcheck.cod > cdprintcheck.out && $(abspath $(tools)cdcheck$(prg)) cdprintcheck.out",cod)

$(tests)cdoptcheck: $(tools)cdopt$(prg) $(tools)cdcheck$(prg)
	$(call test,"$(abspath $(tools)cdopt$(prg)) cdoptcheck.cod > cdoptcheck.opt && $(abspath $(tools)cdcheck$(prg)) cdoptcheck.opt",cod)

$(tests)cdrun: $(tools)cdrun$(prg)
	$(call test,"$(abspath $(tools)cdrun$(prg)) cdrun.cod",cod)

$(tests)cdprintrun: $(tools)asmprint$(prg) $(tools)cdrun$(prg)
	$(call test,"$(abspath $(tools)asmprint$(prg)) cdprintrun.cod > cdprintrun.out && $(abspath $(tools)cdrun$(prg)) cdprintrun.out",cod)

$(tests)cdoptrun: $(tools)cdopt$(prg) $(tools)cdrun$(prg)
	$(call test,"$(abspath $(tools)cdopt$(prg)) cdoptrun.cod > cdoptrun.opt && $(abspath $(tools)cdrun$(prg)) cdoptrun.opt",cod)

$(tests)cddos: $(tools)cdamd16$(prg) $(tools)linkbin$(prg) $(runtime)amd16run.obf $(runtime)dosrun.obf
	$(call test,"$(abspath $(tools)cdamd16$(prg)) cddos.cod && $(abspath $(tools)linkbin$(prg) $(runtime)amd16run.obf $(runtime)dosrun.obf) cddos.obf && $(curr)cddos.com",cod)

$(tests)cdmmixsim: $(tools)cdmmix$(prg) $(tools)linkbin$(prg) $(runtime)mmixrun.obf $(runtime)mmixsimrun.obf
	$(call test,"$(abspath $(tools)cdmmix$(prg)) cdmmixsim.cod && $(abspath $(tools)linkbin$(prg) $(runtime)mmixrun.obf $(runtime)mmixsimrun.obf) cdmmixsim.obf && mmix cdmmixsim.mmo",cod)

$(tests)cdor1ksim: $(tools)cdor1k$(prg) $(tools)linkbin$(prg) $(runtime)or1krun.obf $(runtime)or1ksimrun.obf
	$(call test,"$(abspath $(tools)cdor1k$(prg)) cdor1ksim.cod && $(abspath $(tools)linkbin$(prg) $(runtime)or1krun.obf $(runtime)or1ksimrun.obf) cdor1ksim.obf && or1ksim -q -m 1m cdor1ksim",cod)

$(tests)cdwebassembly: $(tools)cdwasm$(prg) $(tools)linkbin$(prg) $(runtime)wasmrun.obf $(runtime)webassemblyrun.obf
	$(call test,"$(abspath $(tools)cdwasm$(prg)) cdwebassembly.cod && $(abspath $(tools)linkbin$(prg) $(runtime)wasmrun.obf $(runtime)webassemblyrun.obf) cdwebassembly.obf && wasm-interp cdwebassembly.wasm",cod)

$(addprefix $(tests)cd, $(filter atmega%, $(environments))): $(tests)cdatmega%: $(tools)cdavr$(prg) $(tools)linkhex$(prg) $(runtime)avrrun.obf $(runtime)atmega%run.obf $(runtime)avrsimrun.obf
	$(call test,"$(abspath $(tools)cdavr$(prg)) cdatmega$*.cod && $(abspath $(tools)linkhex$(prg) $(runtime)avrrun.obf $(runtime)atmega$*run.obf $(runtime)avrsimrun.obf) cdatmega$*.obf && simavr -m atmega$* -f 100000 cdatmega$*.hex",cod)

$(addprefix $(tests)cd, $(filter axtmega%, $(environments))): $(tests)cdaxtmega%: $(tools)cdavrxt$(prg) $(tools)linkhex$(prg) $(runtime)avrxtrun.obf $(runtime)axtmega%run.obf $(runtime)avrsimrun.obf
	$(call test,"$(abspath $(tools)cdavrxt$(prg)) cdaxtmega$*.cod && $(abspath $(tools)linkhex$(prg) $(runtime)avrxtrun.obf $(runtime)axtmega$*run.obf $(runtime)avrsimrun.obf) cdaxtmega$*.obf && simavr -m atmega$* -f 100000 cdaxtmega$*.hex",cod)

$(addprefix $(tests)cd, $(filter %darwin, $(environments))): $(tests)cd%darwin: $(tools)cd%$(prg) $(tools)linkbin$(prg) $(runtimep)%run.obf $(runtimep)%darwinrun.obf
	$(call test,"$(abspath $(tools)cd$*$(prg)) cd$*darwin.cod && $(abspath $(tools)linkbin$(prg) $(runtime)$*run.obf $(runtime)$*darwinrun.obf) cd$*darwin.obf && $(curr)cd$*darwin",cod)

$(addprefix $(tests)cd, $(filter %linux, $(environments))): $(tests)cd%linux: $(tools)cd%$(prg) $(tools)linkbin$(prg) $(runtimep)%run.obf $(runtimep)%linuxrun.obf
	$(call test,"$(abspath $(tools)cd$*$(prg)) cd$*linux.cod && $(abspath $(tools)linkbin$(prg) $(runtime)$*run.obf $(runtime)$*linuxrun.obf) cd$*linux.obf && $(curr)cd$*linux",cod)

$(addprefix $(tests)cd, $(filter win%, $(environments))): $(tests)cdwin%: $(tools)cdamd%$(prg) $(tools)linkbin$(prg) $(runtime)amd%run.obf $(runtime)win%run.obf
	$(call test,"$(abspath $(tools)cdamd$*$(prg)) cdwin$*.cod && $(abspath $(tools)linkbin$(prg) $(runtime)amd$*run.obf $(runtime)win$*run.obf) cdwin$*.obf && $(curr)cdwin$*.exe",cod)

.PHONY: $(tests)cpp
$(tests)cpp: $(addprefix $(tests)cpp, check printcheck run printrun code $(hostenvironments))

$(addprefix $(tests)cpp, cppcheck check printcheck dump): $(tests)stdcppcheck.tst
$(addprefix $(tests)cpp, check printcheck dump): $(tests)extcppcheck.tst

$(addprefix $(tests)cpp, cpprun run printrun code optcode $(testenvironments)): $(tests)stdcpprun.tst
$(addprefix $(tests)cpp, run printrun code optcode $(testenvironments)): $(tests)extcpprun.tst

$(tests)cppcppcheck:
	$(call test,"$(cc) $(ccheckflags) cppcppcheck.cpp",cpp)

$(tests)cppcpprun:
	$(call test,"$(cc) $(crunflags) cppcpprun.cpp && $(ld) $(lrunflags)cppcpprun$(prg) cppcpprun$(o) && $(curr)cppcpprun$(prg)",cpp)

$(tests)cppcheck: $(tools)cppcheck$(prg) $(hdr)
	$(call test,"$(abspath $(tools)cppcheck$(prg)) cppcheck.cpp",cpp)

$(tests)cppprintcheck: $(tools)cppprint$(prg) $(tools)cppcheck$(prg) $(hdr)
	$(call test,"$(abspath $(tools)cppprint$(prg)) cppprintcheck.cpp > cppprintcheck.out && $(abspath $(tools)cppcheck$(prg)) cppprintcheck.out",cpp)

$(tests)cppdump: $(tools)cppdump$(prg) $(hdr) $(tests)cpp.dtd
	$(call test,"$(abspath $(tools)cppdump$(prg)) cppdump.cpp && xmllint --noout --valid --path $(abspath $(tests)) cppdump.xml",cpp)

$(tests)cpprun: $(tools)cpprun$(prg) $(hdr) $(runtime_cpprunrun.cpp)
	$(call test,"$(abspath $(tools)cpprun$(prg) $(runtime)cpprunrun.cpp) cpprun.cpp",cpp)

$(tests)cppprintrun: $(tools)cppprint$(prg) $(tools)cpprun$(prg) $(hdr) $(runtime_cpprunrun.cpp)
	$(call test,"$(abspath $(tools)cppprint$(prg)) cppprintrun.cpp > cppprintrun.out && $(abspath $(tools)cpprun$(prg) $(runtime)cpprunrun.cpp) cppprintrun.out",cpp)

$(tests)cppcode: $(tools)cppcode$(prg) $(tools)cdrun$(prg) $(runtime)coderun.cod $(runtime)cppcoderun.cod
	$(call test,"$(abspath $(tools)cppcode$(prg)) cppcode.cpp && $(abspath $(tools)cdrun$(prg) $(runtime)coderun.cod $(runtime)cppcoderun.cod) cppcode.cod",cpp)

$(tests)cppoptcode: $(tools)cppcode$(prg) $(tools)cdopt$(prg) $(tools)cdrun$(prg) $(runtime)coderun.cod $(runtime)cppcoderun.cod
	$(call test,"$(abspath $(tools)cppcode$(prg)) cppoptcode.cpp && $(abspath $(tools)cdopt$(prg)) cppoptcode.cod > cppoptcode.opt && $(abspath $(tools)cdrun$(prg) $(runtime)coderun.cod $(runtime)cppcoderun.cod) cppoptcode.opt",cpp)

$(tests)cppdos: $(tools)cppamd16$(prg) $(tools)linkbin$(prg) $(runtime)amd16run.obf $(runtime)dosrun.obf $(runtime)cppamd16run.lib
	$(call test,"$(abspath $(tools)cppamd16$(prg)) cppdos.cpp && $(abspath $(tools)linkbin$(prg) $(runtime)amd16run.obf $(runtime)dosrun.obf $(runtime)cppamd16run.lib) cppdos.obf && $(curr)cppdos.com",cpp)

$(tests)cppmmixsim: $(tools)cppmmix$(prg) $(tools)linkbin$(prg) $(runtime)mmixrun.obf $(runtime)mmixsimrun.obf $(runtime)cppmmixrun.lib
	$(call test,"$(abspath $(tools)cppmmix$(prg)) cppmmixsim.cpp && $(abspath $(tools)linkbin$(prg) $(runtime)mmixrun.obf $(runtime)mmixsimrun.obf $(runtime)cppmmixrun.lib) cppmmixsim.obf && mmix cppmmixsim.mmo",cpp)

$(tests)cppor1ksim: $(tools)cppor1k$(prg) $(tools)linkbin$(prg) $(runtime)or1krun.obf $(runtime)or1ksimrun.obf $(runtime)cppor1krun.lib
	$(call test,"$(abspath $(tools)cppor1k$(prg)) cppor1ksim.cpp && $(abspath $(tools)linkbin$(prg) $(runtime)or1krun.obf $(runtime)or1ksimrun.obf $(runtime)cppor1krun.lib) cppor1ksim.obf && or1ksim -q -m 1m cppor1ksim",cpp)

$(tests)cppwebassembly: $(tools)cppwasm$(prg) $(tools)linkbin$(prg) $(runtime)wasmrun.obf $(runtime)webassemblyrun.obf $(runtime)cppwasmrun.lib
	$(call test,"$(abspath $(tools)cppwasm$(prg)) cppwebassembly.cpp && $(abspath $(tools)linkbin$(prg) $(runtime)wasmrun.obf $(runtime)webassemblyrun.obf $(runtime)cppwasmrun.lib) cppwebassembly.obf && wasm-interp cppwebassembly.wasm",cpp)

$(addprefix $(tests)cpp, $(filter atmega%, $(environments))): $(tests)cppatmega%: $(tools)cppavr$(prg) $(tools)linkhex$(prg) $(runtime)avrrun.obf $(runtime)atmega%run.obf $(runtime)cppavrrun.lib $(runtime)avrsimrun.obf
	$(call test,"$(abspath $(tools)cppavr$(prg)) cppatmega$*.cpp && $(abspath $(tools)linkhex$(prg) $(runtime)avrrun.obf $(runtime)atmega$*run.obf $(runtime)cppavrrun.lib $(runtime)avrsimrun.obf) cppatmega$*.obf && simavr -m atmega$* -f 100000 cppatmega$*.hex",cpp)

$(addprefix $(tests)cpp, $(filter axtmega%, $(environments))): $(tests)cppaxtmega%: $(tools)cppavrxt$(prg) $(tools)linkhex$(prg) $(runtime)avrxtrun.obf $(runtime)axtmega%run.obf $(runtime)cppavrxtrun.lib $(runtime)avrsimrun.obf
	$(call test,"$(abspath $(tools)cppavrxt$(prg)) cppaxtmega$*.cpp && $(abspath $(tools)linkhex$(prg) $(runtime)avrxtrun.obf $(runtime)axtmega$*run.obf $(runtime)cppavrxtrun.lib $(runtime)avrsimrun.obf) cppaxtmega$*.obf && simavr -m atmega$* -f 100000 cppaxtmega$*.hex",cpp)

$(addprefix $(tests)cpp, $(filter %darwin, $(environments))): $(tests)cpp%darwin: $(tools)cpp%$(prg) $(tools)linkbin$(prg) $(runtimep)%run.obf $(runtimep)%darwinrun.obf $(runtime)cpp%run.lib
	$(call test,"$(abspath $(tools)cpp$*$(prg)) cpp$*darwin.cpp && $(abspath $(tools)linkbin$(prg) $(runtime)$*run.obf $(runtime)$*darwinrun.obf $(runtime)cpp$*run.lib) cpp$*darwin.obf && $(curr)cpp$*darwin",cpp)

$(addprefix $(tests)cpp, $(filter %linux, $(environments))): $(tests)cpp%linux: $(tools)cpp%$(prg) $(tools)linkbin$(prg) $(runtimep)%run.obf $(runtimep)%linuxrun.obf $(runtime)cpp%run.lib
	$(call test,"$(abspath $(tools)cpp$*$(prg)) cpp$*linux.cpp && $(abspath $(tools)linkbin$(prg) $(runtime)$*run.obf $(runtime)$*linuxrun.obf $(runtime)cpp$*run.lib) cpp$*linux.obf && $(curr)cpp$*linux",cpp)

$(addprefix $(tests)cpp, $(filter win%, $(environments))): $(tests)cppwin%: $(tools)cppamd%$(prg) $(tools)linkbin$(prg) $(runtime)amd%run.obf $(runtime)win%run.obf $(runtime)cppamd%run.lib
	$(call test,"$(abspath $(tools)cppamd$*$(prg)) cppwin$*.cpp && $(abspath $(tools)linkbin$(prg) $(runtime)amd$*run.obf $(runtime)win$*run.obf $(runtime)cppamd$*run.lib) cppwin$*.obf && $(curr)cppwin$*.exe",cpp)

.PHONY: $(tests)false
$(tests)false: $(addprefix $(tests)fal, check printcheck run printrun code $(hostenvironments))

$(addprefix $(tests)fal, check printcheck dump cppcheck): $(tests)falcheck.tst
$(addprefix $(tests)fal, run printrun cpprun code optcode $(testenvironments)): $(tests)falrun.tst

$(tests)falcheck: $(tools)falcheck$(prg)
	$(call test,"$(abspath $(tools)falcheck$(prg)) falcheck.fal",fal)

$(tests)falprintcheck: $(tools)falprint$(prg) $(tools)falcheck$(prg)
	$(call test,"$(abspath $(tools)falprint$(prg)) falprintcheck.fal > falprintcheck.out && $(abspath $(tools)falcheck$(prg)) falprintcheck.out",fal)

$(tests)faldump: $(tools)faldump$(prg) $(tests)false.dtd
	$(call test,"$(abspath $(tools)faldump$(prg)) faldump.fal && xmllint --noout --valid --path $(abspath $(tests)) faldump.xml",fal)

$(tests)falrun: $(tools)falrun$(prg)
	$(call test,"$(abspath $(tools)falrun$(prg)) falrun.fal",fal)

$(tests)falprintrun: $(tools)falprint$(prg) $(tools)falrun$(prg)
	$(call test,"$(abspath $(tools)falprint$(prg)) falprintrun.fal > falprintrun.out && $(abspath $(tools)falrun$(prg)) falprintrun.out",fal)

$(tests)falcppcheck: $(tools)falcpp$(prg)
	$(call test,"$(abspath $(tools)falcpp$(prg)) falcppcheck.fal && $(cc) $(ccheckflags) falcppcheck.cpp",fal)

$(tests)falcpprun: $(tools)falcpp$(prg)
	$(call test,"$(abspath $(tools)falcpp$(prg)) falcpprun.fal && $(cc) $(crunflags) falcpprun.cpp && $(ld) $(lrunflags)falcpprun$(prg) falcpprun$(o) && $(curr)falcpprun$(prg)",fal)

$(tests)falcode: $(tools)falcode$(prg) $(tools)cdrun$(prg) $(runtime)coderun.cod
	$(call test,"$(abspath $(tools)falcode$(prg)) falcode.fal && $(abspath $(tools)cdrun$(prg) $(runtime)coderun.cod) falcode.cod",fal)

$(tests)faloptcode: $(tools)falcode$(prg) $(tools)cdopt$(prg) $(tools)cdrun$(prg) $(runtime)coderun.cod
	$(call test,"$(abspath $(tools)falcode$(prg)) faloptcode.fal && $(abspath $(tools)cdopt$(prg)) faloptcode.cod > faloptcode.opt && $(abspath $(tools)cdrun$(prg) $(runtime)coderun.cod) faloptcode.opt",fal)

$(tests)faldos: $(tools)falamd16$(prg) $(tools)linkbin$(prg) $(runtime)amd16run.obf $(runtime)dosrun.obf
	$(call test,"$(abspath $(tools)falamd16$(prg)) faldos.fal && $(abspath $(tools)linkbin$(prg) $(runtime)amd16run.obf $(runtime)dosrun.obf) faldos.obf && $(curr)faldos.com",fal)

$(tests)falmmixsim: $(tools)falmmix$(prg) $(tools)linkbin$(prg) $(runtime)mmixrun.obf $(runtime)mmixsimrun.obf
	$(call test,"$(abspath $(tools)falmmix$(prg)) falmmixsim.fal && $(abspath $(tools)linkbin$(prg) $(runtime)mmixrun.obf $(runtime)mmixsimrun.obf) falmmixsim.obf && mmix falmmixsim.mmo",fal)

$(tests)falor1ksim: $(tools)falor1k$(prg) $(tools)linkbin$(prg) $(runtime)or1krun.obf $(runtime)or1ksimrun.obf
	$(call test,"$(abspath $(tools)falor1k$(prg)) falor1ksim.fal && $(abspath $(tools)linkbin$(prg) $(runtime)or1krun.obf $(runtime)or1ksimrun.obf) falor1ksim.obf && or1ksim -q -m 1m falor1ksim",fal)

$(tests)falwebassembly: $(tools)falwasm$(prg) $(tools)linkbin$(prg) $(runtime)wasmrun.obf $(runtime)webassemblyrun.obf
	$(call test,"$(abspath $(tools)falwasm$(prg)) falwebassembly.fal && $(abspath $(tools)linkbin$(prg) $(runtime)wasmrun.obf $(runtime)webassemblyrun.obf) falwebassembly.obf && wasm-interp falwebassembly.wasm",fal)

$(addprefix $(tests)fal, $(filter atmega%, $(environments))): $(tests)falatmega%: $(tools)falavr$(prg) $(tools)linkhex$(prg) $(runtime)avrrun.obf $(runtime)atmega%run.obf $(runtime)avrsimrun.obf
	$(call test,"$(abspath $(tools)falavr$(prg)) falatmega$*.fal && $(abspath $(tools)linkhex$(prg) $(runtime)avrrun.obf $(runtime)atmega$*run.obf $(runtime)avrsimrun.obf) falatmega$*.obf && simavr -m atmega$* -f 100000 falatmega$*.hex",fal)

$(addprefix $(tests)fal, $(filter axtmega%, $(environments))): $(tests)falaxtmega%: $(tools)falavrxt$(prg) $(tools)linkhex$(prg) $(runtime)avrxtrun.obf $(runtime)axtmega%run.obf $(runtime)avrsimrun.obf
	$(call test,"$(abspath $(tools)falavrxt$(prg)) falaxtmega$*.fal && $(abspath $(tools)linkhex$(prg) $(runtime)avrxtrun.obf $(runtime)axtmega$*run.obf $(runtime)avrsimrun.obf) falaxtmega$*.obf && simavr -m atmega$* -f 100000 falaxtmega$*.hex",fal)

$(addprefix $(tests)fal, $(filter %darwin, $(environments))): $(tests)fal%darwin: $(tools)fal%$(prg) $(tools)linkbin$(prg) $(runtimep)%run.obf $(runtimep)%darwinrun.obf
	$(call test,"$(abspath $(tools)fal$*$(prg)) fal$*darwin.fal && $(abspath $(tools)linkbin$(prg) $(runtime)$*run.obf $(runtime)$*darwinrun.obf) fal$*darwin.obf && $(curr)fal$*darwin",fal)

$(addprefix $(tests)fal, $(filter %linux, $(environments))): $(tests)fal%linux: $(tools)fal%$(prg) $(tools)linkbin$(prg) $(runtimep)%run.obf $(runtimep)%linuxrun.obf
	$(call test,"$(abspath $(tools)fal$*$(prg)) fal$*linux.fal && $(abspath $(tools)linkbin$(prg) $(runtime)$*run.obf $(runtime)$*linuxrun.obf) fal$*linux.obf && $(curr)fal$*linux",fal)

$(addprefix $(tests)fal, $(filter win%, $(environments))): $(tests)falwin%: $(tools)falamd%$(prg) $(tools)linkbin$(prg) $(runtime)amd%run.obf $(runtime)win%run.obf
	$(call test,"$(abspath $(tools)falamd$*$(prg)) falwin$*.fal && $(abspath $(tools)linkbin$(prg) $(runtime)amd$*run.obf $(runtime)win$*run.obf) falwin$*.obf && $(curr)falwin$*.exe",fal)

.PHONY: $(tests)oberon
$(tests)oberon: $(addprefix $(tests)ob, check printcheck run printrun code $(hostenvironments))

$(addprefix $(tests)ob, check printcheck dump cppcheck): $(addprefix $(tests), stdobcheck.tst extobcheck.tst import.sym generic.sym package.packaged.sym)
$(addprefix $(tests)ob, run printrun cpprun code optcode $(testenvironments)): $(addprefix $(tests), stdobrun.tst extobrun.tst generic.sym)

$(tests)obcheck: $(tools)obcheck$(prg)
	$(call test,"$(abspath $(tools)obcheck$(prg)) obcheck.mod",mod)

$(tests)obprintcheck: $(tools)obprint$(prg) $(tools)obcheck$(prg)
	$(call test,"$(abspath $(tools)obprint$(prg)) obprintcheck.mod > obprintcheck.out && $(abspath $(tools)obcheck$(prg)) obprintcheck.out",mod)

$(tests)obdump: $(tools)obdump$(prg) $(tests)oberon.dtd
	$(call test,"$(abspath $(tools)obdump$(prg)) obdump.mod && xmllint --noout --valid --path $(abspath $(tests)) obdump.xml",mod)

$(tests)obrun: $(tools)obrun$(prg)
	$(call test,"$(abspath $(tools)obrun$(prg)) $(abspath $(tests)generic.sym) obrun.mod",mod)

$(tests)obprintrun: $(tools)obprint$(prg) $(tools)obrun$(prg)
	$(call test,"$(abspath $(tools)obprint$(prg)) obprintrun.mod > obprintrun.out && $(abspath $(tools)obrun$(prg)) $(abspath $(tests)generic.sym) obprintrun.out",mod)

.INTERMEDIATE: $(addprefix $(tests), import.cpp import.hpp generic.cpp generic.hpp package.packaged.cpp package.packaged.hpp obcpprun$(o))

$(addprefix $(tests), import.cpp generic.cpp package.packaged.cpp): %.cpp: $(tools)obcpp$(prg) %.sym
	@cd $(tests) && $(prev)$(tools)obcpp$(prg) $(notdir $*.sym)

$(addprefix $(tests), import.hpp generic.hpp package.packaged.hpp): %.hpp: $(tools)obcpp$(prg) %.sym
	@cd $(tests) && $(prev)$(tools)obcpp$(prg) $(notdir $*.sym)

$(addprefix $(tests), obcpprun$(o)): $(addprefix $(runtime), obcpprun.hpp obcpprun.cpp)
	@cd $(tests) && $(cc) $(crunflags) $(prev)$(runtime)obcpprun.cpp

$(tests)obcppcheck: $(tools)obcpp$(prg) $(runtime)obcpprun.hpp $(addprefix $(tests), import.cpp import.hpp generic.cpp generic.hpp package.packaged.cpp package.packaged.hpp)
	$(call test,"$(abspath $(tools)obcpp$(prg)) obcppcheck.mod && $(cc) $(ccheckflags) -I $(abspath $(tests)) -I $(abspath $(runtime)) test.cpp",mod)

$(tests)obcpprun: $(tools)obcpp$(prg) $(addprefix $(tests), generic.cpp generic.hpp obcpprun$(o))
	$(call test,"$(abspath $(tools)obcpp$(prg)) obcpprun.mod && $(cc) $(crunflags) -I $(abspath $(tests)) -I $(abspath $(runtime)) test.cpp && $(ld) $(lrunflags)obcpprun$(prg) test$(o) $(abspath $(tests)obcpprun$(o)) && $(curr)obcpprun$(prg)",mod)

$(tests)obcode: $(tools)obcode$(prg) $(tools)cdrun$(prg) $(runtime)coderun.cod
	$(call test,"$(abspath $(tools)obcode$(prg)) obcode.mod && $(abspath $(tools)cdrun$(prg) $(runtime)coderun.cod) obcode.cod",mod)

$(tests)oboptcode: $(tools)obcode$(prg) $(tools)cdopt$(prg) $(tools)cdrun$(prg) $(runtime)coderun.cod
	$(call test,"$(abspath $(tools)obcode$(prg)) oboptcode.mod && $(abspath $(tools)cdopt$(prg)) oboptcode.cod > oboptcode.opt && $(abspath $(tools)cdrun$(prg) $(runtime)coderun.cod) oboptcode.opt",mod)

$(tests)obdos: $(tools)obamd16$(prg) $(tools)linkbin$(prg) $(runtime)amd16run.obf $(runtime)dosrun.obf
	$(call test,"$(abspath $(tools)obamd16$(prg)) obdos.mod && $(abspath $(tools)linkbin$(prg) $(runtime)amd16run.obf $(runtime)dosrun.obf) obdos.obf && $(curr)obdos.com",mod)

$(tests)obmmixsim: $(tools)obmmix$(prg) $(tools)linkbin$(prg) $(runtime)mmixrun.obf $(runtime)mmixsimrun.obf
	$(call test,"$(abspath $(tools)obmmix$(prg)) obmmixsim.mod && $(abspath $(tools)linkbin$(prg) $(runtime)mmixrun.obf $(runtime)mmixsimrun.obf) obmmixsim.obf && mmix obmmixsim.mmo",mod)

$(tests)obor1ksim: $(tools)obor1k$(prg) $(tools)linkbin$(prg) $(runtime)or1krun.obf $(runtime)or1ksimrun.obf
	$(call test,"$(abspath $(tools)obor1k$(prg)) obor1ksim.mod && $(abspath $(tools)linkbin$(prg) $(runtime)or1krun.obf $(runtime)or1ksimrun.obf) obor1ksim.obf && or1ksim -q -m 1m obor1ksim",mod)

$(tests)obwebassembly: $(tools)obwasm$(prg) $(tools)linkbin$(prg) $(runtime)wasmrun.obf $(runtime)webassemblyrun.obf
	$(call test,"$(abspath $(tools)obwasm$(prg)) obwebassembly.mod && $(abspath $(tools)linkbin$(prg) $(runtime)wasmrun.obf $(runtime)webassemblyrun.obf) obwebassembly.obf && wasm-interp obwebassembly.wasm",mod)

$(addprefix $(tests)ob, $(filter atmega%, $(environments))): $(tests)obatmega%: $(tools)obavr$(prg) $(tools)linkhex$(prg) $(runtime)avrrun.obf $(runtime)atmega%run.obf $(runtime)avrsimrun.obf
	$(call test,"$(abspath $(tools)obavr$(prg)) obatmega$*.mod && $(abspath $(tools)linkhex$(prg) $(runtime)avrrun.obf $(runtime)atmega$*run.obf $(runtime)avrsimrun.obf) obatmega$*.obf && simavr -m atmega$* -f 100000 obatmega$*.hex",mod)

$(addprefix $(tests)ob, $(filter axtmega%, $(environments))): $(tests)obaxtmega%: $(tools)obavrxt$(prg) $(tools)linkhex$(prg) $(runtime)avrxtrun.obf $(runtime)axtmega%run.obf $(runtime)avrsimrun.obf
	$(call test,"$(abspath $(tools)obavrxt$(prg)) obaxtmega$*.mod && $(abspath $(tools)linkhex$(prg) $(runtime)avrxtrun.obf $(runtime)axtmega$*run.obf $(runtime)avrsimrun.obf) obaxtmega$*.obf && simavr -m atmega$* -f 100000 obaxtmega$*.hex",mod)

$(addprefix $(tests)ob, $(filter %darwin, $(environments))): $(tests)ob%darwin: $(tools)ob%$(prg) $(tools)linkbin$(prg) $(runtimep)%run.obf $(runtimep)%darwinrun.obf $(runtime)ob%run.lib
	$(call test,"$(abspath $(tools)ob$*$(prg)) ob$*darwin.mod && $(abspath $(tools)linkbin$(prg) $(runtime)$*run.obf $(runtime)$*darwinrun.obf $(runtime)ob$*run.lib) ob$*darwin.obf && $(curr)ob$*darwin",mod)

$(addprefix $(tests)ob, $(filter %linux, $(environments))): $(tests)ob%linux: $(tools)ob%$(prg) $(tools)linkbin$(prg) $(runtimep)%run.obf $(runtimep)%linuxrun.obf $(runtime)ob%run.lib
	$(call test,"$(abspath $(tools)ob$*$(prg)) ob$*linux.mod && $(abspath $(tools)linkbin$(prg) $(runtime)$*run.obf $(runtime)$*linuxrun.obf $(runtime)ob$*run.lib) ob$*linux.obf && $(curr)ob$*linux",mod)

$(addprefix $(tests)ob, $(filter win%, $(environments))): $(tests)obwin%: $(tools)obamd%$(prg) $(tools)linkbin$(prg) $(runtime)amd%run.obf $(runtime)win%run.obf $(runtime)obamd%run.lib
	$(call test,"$(abspath $(tools)obamd$*$(prg)) obwin$*.mod && $(abspath $(tools)linkbin$(prg) $(runtime)amd$*run.obf $(runtime)win$*run.obf $(runtime)obamd$*run.lib) obwin$*.obf && $(curr)obwin$*.exe",mod)

.PHONY: $(tests)assembly
$(tests)assembly: $(foreach architecture, $(asmarchitectures), $(addprefix $(tests)$(architecture), asm printasm))

$(asmarchitectures:%=$(testsp)%asm): $(testsp)%asm: $(tests)assembly.tst $(tests)binary.tst $(testsp)%asm.tst $(toolsp)%asm$(prg)
	$(call test,"$(abspath $(tools)$*asm$(prg)) $*asm.asm",asm)

$(asmarchitectures:%=$(testsp)%printasm): $(testsp)%printasm: $(tests)assembly.tst $(tests)binary.tst $(testsp)%asm.tst $(tools)asmprint$(prg) $(toolsp)%asm$(prg)
	$(call test,"$(abspath $(tools)asmprint$(prg)) $*printasm.asm > $*printasm.out && $(abspath $(tools)$*asm$(prg)) $*printasm.out",asm)

.PHONY: $(tests)serialization
$(tests)serialization: $(addprefix $(tests), $(addsuffix dump, $(filter-out cd asm, $(languages))))

.PHONY: $(tests)translation
$(tests)translation: $(addprefix $(tests), $(foreach language, $(filter-out cd cpp asm, $(languages)), $(addprefix $(language), cppcheck cpprun)))

.PHONY: $(tests)code
$(tests)code: $(addprefix $(tests), $(addsuffix code, $(filter-out cd asm, $(languages))))

.PHONY: $(tests)optimization
$(tests)optimization: $(addprefix $(tests), cdoptcheck cdoptrun $(addsuffix optcode, $(filter-out cd asm, $(languages))))

.PHONY: $(tests)host
$(tests)host: $(addprefix $(tests), $(hostenvironments))

.PHONY: $(addprefix $(tests), $(testenvironments))
$(foreach environment, $(testenvironments), $(eval $(tests)$(environment): $(foreach language, $(filter-out asm, $(languages)), $(tests)$(language)$(environment))))

tests: $(addprefix $(tests), linkage documentation $(languagenamespaces))

# checks

checks := $(call path,checks/)

.PHONY: $(checks)lines
$(checks)lines: $(utilities)linecheck$(prg)
	@$(utilities)linecheck$(prg) $(call path, makefile readme $(wildcard licenses/*.txt))
	@$(utilities)linecheck$(prg) $(call path, $(wildcard tools/*.cpp tools/*.hpp tools/*.def))
	@$(utilities)linecheck$(prg) $(call path, $(wildcard utilities/*.cpp utilities/*.hpp))
	@$(utilities)linecheck$(prg) $(call path, $(wildcard runtime/*.asm runtime/*.cpp runtime/*.hpp))
	@$(utilities)linecheck$(prg) $(call path, $(wildcard libraries/cpp/*.cpp libraries/cpp/*.h libraries/cpp/api/* libraries/cpp/def/* libraries/oberon/*.mod) $(filter-out $(wildcard libraries/cpp/*.*), $(wildcard libraries/cpp/*)))
	@$(utilities)linecheck$(prg) $(call path, $(wildcard documentation/*.tex documentation/*.tab) documentation/references.bib documentation/ecsd.1)
	@$(utilities)linecheck$(prg) $(call path, $(wildcard tests/*.tst tests/*.dtd tests/*.sym))

.PHONY: $(checks)headers
$(checks)headers: $(tools)cppcheck$(prg)
	@$(cc) $(ccheckflags) $(call path, $(wildcard tools/*.hpp) $(wildcard utilities/*.hpp) runtime/obcpprun.hpp)
	@$(tools)cppcheck$(prg) $(hdr) $(api)

checks: $(addprefix $(checks), lines headers)

# maintenance

clean:
	-@$(rm) $(drv)
	-@$(rm) $(obj)
	-@$(rm) $(bin)
	-@$(rm) $(obf)
	-@$(rm) $(run)
	-@$(rd) $(run:.obf=.dbg)
	-@$(rm) $(lib)
	-@$(rd) $(lib:.lib=.dbg)
	-@$(rm) $(cod)
	-@$(rd) $(cod:.cod=.dbg)
	-@$(rm) $(sym)
	-@$(rm) $(set)
	-@$(rm) $(doc)
	-@$(rm) $(aux)
	-@$(rm) $(idx)
	-@$(rm) $(pdf)
	-@$(rm) $(tst)
	-@$(rm) $(res)

dependencies: $(utilities)depwalk$(prg) $(drv)
	@$(utilities)depwalk$(prg) tools=$(tools) $(tls) $(drv)
	@$(utilities)depwalk$(prg) utilities=$(utilities) $(uts)
	@$(utilities)depwalk$(prg) cpplibrary=$(cpplibrary) apilibrary=$(apilibrary) deflibrary=$(deflibrary) runtime=$(runtime) $(hdr) $(std) $(def) $(api) $(cpp)
	@$(utilities)depwalk$(prg) oblibrary=$(oblibrary) $(mod)

# installation

targets := $(call path,targets/)
targetsp := $(call pathp,targets/)

.PHONY: $(addprefix $(tools), $(languagenamespaces))
$(foreach language, $(languages), $(eval $(tools)$(call lookup, $(language), language, namespace): $(utilities)ecsd$(prg) $(addprefix $(tools), $(addsuffix $(prg), $(filter $(language)%, $(preprocessors) $(printers) $(checkers) $(serializers) $(interpreters) $(transpilers) $(generators))))))
$(tools)assembly: $(addprefix $(tools), $(assemblers) $(disassemblers))

.PHONY: targets $(addprefix $(targets), host code $(environments))
targets: $(addprefix $(targets), $(environments))
$(targets)host: $(addprefix $(targets), $(hostenvironments))
$(targets)code: $(utilities)ecsd$(prg) $(addprefix $(tools), $(addsuffix $(prg), cppcode obcode cdrun)) $(cod)
$(foreach environment, $(environments), $(eval $(targets)$(environment): $(utilities)ecsd$(prg) $(let target, $(call lookup, $(environment), environment, target), $(let architecture, $(call lookup, $(environment), environment, architecture), \
	$(addprefix $(tools), $(addsuffix $(prg), cpp$(target) ob$(target) $(architecture)asm $(architecture)dism linklib linkbin linkmem mapplace mapsearch)) \
	$(addprefix $(runtime), $(target)run.obf cpp$(target)run.lib ob$(target)run.lib $(environment)run.obf) $(sym)))))
$(addprefix $(targets), $(filter atmega% axtmega%, $(environments))): $(tools)linkhex$(prg)
$(addprefix $(targets), $(filter %linux, $(environments))): $(targetsp)%linux: $(tools)dbgdwarf$(prg) $(addprefix $(runtime), %libdl.obf %libpthread.obf %libsdl.obf)
$(addprefix $(targets), $(filter win%, $(environments))): $(targets)win%: $(addprefix $(runtime), win%api.obf win%sdl.obf)
$(targets)tos: $(tools)linkprg$(prg) $(addprefix $(runtime), tosapi.obf)

prefix := /usr/local
ecsdir := $(prefix)/lib/ecs
bindir := $(prefix)/bin
mandir := $(prefix)/share/man
man1dir := $(mandir)/man1
docdir := $(prefix)/share/doc/ecs

install: uninstall
	@mkdir -p $(DESTDIR)$(ecsdir)
	@mkdir -p $(DESTDIR)$(ecsdir)/$(tools)
	@cp $(filter $(toolsp)%, $(wildcard $(bin))) $(DESTDIR)$(ecsdir)/$(tools)
	@mkdir -p $(DESTDIR)$(ecsdir)/$(runtime)
	@cp $(wildcard $(obf) $(run) $(lib) $(cod)) $(DESTDIR)$(ecsdir)/$(runtime)
	@mkdir -p $(DESTDIR)$(ecsdir)/$(cpplibrary)
	@cp $(hdr) $(DESTDIR)$(ecsdir)/$(cpplibrary)
	@mkdir -p $(DESTDIR)$(ecsdir)/$(oblibrary)
	@cp $(wildcard $(sym)) $(DESTDIR)$(ecsdir)/$(oblibrary)
	@mkdir -p $(DESTDIR)$(ecsdir)/$(utilities)
	@cp $(utilities)ecsd $(DESTDIR)$(ecsdir)/$(utilities)
	@mkdir -p $(DESTDIR)$(bindir)
	@ln -s $(patsubst $(DESTDIR)$(prefix)/%,../%,$(DESTDIR)$(ecsdir))/$(utilities)ecsd $(DESTDIR)$(bindir)/ecsd
	@mkdir -p $(DESTDIR)$(man1dir)
	@cp $(documentation)ecsd.1 $(DESTDIR)$(man1dir)/ecsd.1
	@mkdir -p $(DESTDIR)$(docdir)
	@cp $(wildcard $(pdf)) $(DESTDIR)$(docdir)

uninstall:
	@rm -f -r $(DESTDIR)$(ecsdir)
	@rm -f $(DESTDIR)$(bindir)/ecsd
	@rm -f $(DESTDIR)$(man1dir)/ecsd.1
	@rm -f -r $(DESTDIR)$(docdir)
