Makefile

# LeoUTF8 Leopard/PPC Makefile.
# Builds LeoUTF8Core, LeoUTF8Foundation, probe tools, reusable artifacts,
# and distribution consumer checks.
#
# This Makefile is intentionally small and Leopard-friendly.
# It does not modify vendor/ sources.

CC = /usr/bin/gcc
AR = /usr/bin/ar

PREFIX = /usr/local
DESTDIR =

COMMON_FLAGS = -Os -arch ppc -mmacosx-version-min=10.5
BUILD_DIR = build-work
DIST_DIR = dist/LeoUTF8
DISTCHECK_DIR = $(BUILD_DIR)/distcheck

UTF8PROC_BUILD = $(BUILD_DIR)/utf8proc
UTF8PROC_LIB = $(UTF8PROC_BUILD)/libutf8proc.a
UTF8PROC_OBJ = $(UTF8PROC_BUILD)/utf8proc.o

CORE_INC = Sources/LeoUTF8Core
CORE_SRC = Sources/LeoUTF8Core/LeoUTF8.c
CORE_HDR = Sources/LeoUTF8Core/LeoUTF8.h
VERSION_SRC = Sources/LeoUTF8Core/LeoUTF8Version.c
VERSION_HDR = Sources/LeoUTF8Core/LeoUTF8Version.h
CORE_OBJ = $(BUILD_DIR)/LeoUTF8.o
VERSION_OBJ = $(BUILD_DIR)/LeoUTF8Version.o
CORE_LIB = $(BUILD_DIR)/libLeoUTF8Core.a

COREFOUNDATION_INC = Sources/LeoUTF8CoreFoundation
COREFOUNDATION_SRC = Sources/LeoUTF8CoreFoundation/LeoUTF8CoreFoundation.c
COREFOUNDATION_HDR = Sources/LeoUTF8CoreFoundation/LeoUTF8CoreFoundation.h
COREFOUNDATION_OBJ = $(BUILD_DIR)/LeoUTF8CoreFoundation.o
COREFOUNDATION_LIB = $(BUILD_DIR)/libLeoUTF8CoreFoundation.a

FOUNDATION_INC = Sources/LeoUTF8Foundation
FOUNDATION_SRC = Sources/LeoUTF8Foundation/LeoUTF8Foundation.m
FOUNDATION_HDR = Sources/LeoUTF8Foundation/LeoUTF8Foundation.h
FOUNDATION_OBJ = $(BUILD_DIR)/LeoUTF8Foundation.o
FOUNDATION_LIB = $(BUILD_DIR)/libLeoUTF8Foundation.a

C_PROBE_SRC = Sources/LeoUTF8CLI/leoutf8_probe.c
C_PROBE_OBJ = $(BUILD_DIR)/leoutf8_probe.o
C_PROBE_BIN = $(BUILD_DIR)/leoutf8_probe

COREFOUNDATION_PROBE_SRC = Sources/LeoUTF8CLI/leoutf8_corefoundation_probe.c
COREFOUNDATION_PROBE_OBJ = $(BUILD_DIR)/leoutf8_corefoundation_probe.o
COREFOUNDATION_PROBE_BIN = $(BUILD_DIR)/leoutf8_corefoundation_probe

FOUNDATION_PROBE_SRC = Sources/LeoUTF8CLI/leoutf8_foundation_probe.m
FOUNDATION_PROBE_OBJ = $(BUILD_DIR)/leoutf8_foundation_probe.o
FOUNDATION_PROBE_BIN = $(BUILD_DIR)/leoutf8_foundation_probe

CONSUMER_CORE_SRC = Tests/consumer_core_probe.c
CONSUMER_CORE_BIN = $(DISTCHECK_DIR)/consumer_core_probe

CONSUMER_COREFOUNDATION_SRC = Tests/consumer_corefoundation_probe.c
CONSUMER_COREFOUNDATION_BIN = $(DISTCHECK_DIR)/consumer_corefoundation_probe

CONSUMER_FOUNDATION_SRC = Tests/consumer_foundation_probe.m
CONSUMER_FOUNDATION_BIN = $(DISTCHECK_DIR)/consumer_foundation_probe

HFSPLUS_PROBE_SRC = Research/HFSPlus/hfsplus_filename_probe.c
HFSPLUS_PROBE_BIN = $(BUILD_DIR)/hfsplus_filename_probe

HFSBOUNDARY_PROBE_SRC = Research/HFSPlus/hfsplus_cfstring_boundary_probe.m
HFSBOUNDARY_PROBE_BIN = $(BUILD_DIR)/hfsplus_cfstring_boundary_probe

HFSCASE_PROBE_SRC = Research/HFSPlus/hfsplus_case_probe.c
HFSCASE_PROBE_BIN = $(BUILD_DIR)/hfsplus_case_probe

HFSCOMPARE_PROBE_SRC = Research/HFSPlus/hfsplus_cfcompare_probe.m
HFSCOMPARE_PROBE_BIN = $(BUILD_DIR)/hfsplus_cfcompare_probe

HFSURL_PROBE_SRC = Research/HFSPlus/hfsplus_url_boundary_probe.m
HFSURL_PROBE_BIN = $(BUILD_DIR)/hfsplus_url_boundary_probe

.PHONY: all libs probes check hfscheck hfsboundarycheck hfscasecheck hfscomparecheck hfsurlcheck clean dist distcheck distclean install utf8proc

all: libs probes

libs: $(CORE_LIB) $(COREFOUNDATION_LIB) $(FOUNDATION_LIB)

probes: $(C_PROBE_BIN) $(COREFOUNDATION_PROBE_BIN) $(FOUNDATION_PROBE_BIN)

check: probes
	$(C_PROBE_BIN)
	$(COREFOUNDATION_PROBE_BIN)
	$(FOUNDATION_PROBE_BIN)

$(BUILD_DIR):
	mkdir -p $(BUILD_DIR)

$(UTF8PROC_LIB): | $(BUILD_DIR)
	rm -rf $(UTF8PROC_BUILD)
	cp -R vendor/utf8proc $(UTF8PROC_BUILD)
	cd $(UTF8PROC_BUILD) && make clean
	cd $(UTF8PROC_BUILD) && make libutf8proc.a \
		CC=$(CC) \
		AR=$(AR) \
		CFLAGS="$(COMMON_FLAGS)" \
		PICFLAG="-fPIC" \
		WCFLAGS="-Wall -Wextra"

utf8proc: $(UTF8PROC_LIB)

$(CORE_OBJ): $(CORE_SRC) $(CORE_HDR) $(UTF8PROC_LIB) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic -Werror \
		-I $(CORE_INC) \
		-isystem $(UTF8PROC_BUILD) \
		-c $(CORE_SRC) \
		-o $(CORE_OBJ)

$(VERSION_OBJ): $(VERSION_SRC) $(VERSION_HDR) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic -Werror \
		-I $(CORE_INC) \
		-c $(VERSION_SRC) \
		-o $(VERSION_OBJ)

$(CORE_LIB): $(CORE_OBJ) $(VERSION_OBJ) $(UTF8PROC_LIB)
	rm -f $(CORE_LIB)
	$(AR) crs $(CORE_LIB) $(CORE_OBJ) $(VERSION_OBJ) $(UTF8PROC_OBJ)

$(COREFOUNDATION_OBJ): $(COREFOUNDATION_SRC) $(COREFOUNDATION_HDR) $(CORE_HDR) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic -Werror \
		-I $(CORE_INC) \
		-I $(COREFOUNDATION_INC) \
		-c $(COREFOUNDATION_SRC) \
		-o $(COREFOUNDATION_OBJ)

$(COREFOUNDATION_LIB): $(COREFOUNDATION_OBJ)
	rm -f $(COREFOUNDATION_LIB)
	$(AR) crs $(COREFOUNDATION_LIB) $(COREFOUNDATION_OBJ)

$(FOUNDATION_OBJ): $(FOUNDATION_SRC) $(FOUNDATION_HDR) $(CORE_HDR) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-Wall -Wextra -Werror \
		-I $(CORE_INC) \
		-I $(FOUNDATION_INC) \
		-c $(FOUNDATION_SRC) \
		-o $(FOUNDATION_OBJ)

$(FOUNDATION_LIB): $(FOUNDATION_OBJ)
	rm -f $(FOUNDATION_LIB)
	$(AR) crs $(FOUNDATION_LIB) $(FOUNDATION_OBJ)

$(C_PROBE_OBJ): $(C_PROBE_SRC) $(CORE_HDR) $(UTF8PROC_LIB) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-I $(CORE_INC) \
		-isystem $(UTF8PROC_BUILD) \
		-c $(C_PROBE_SRC) \
		-o $(C_PROBE_OBJ)

$(C_PROBE_BIN): $(C_PROBE_OBJ) $(CORE_LIB)
	$(CC) \
		-arch ppc -mmacosx-version-min=10.5 \
		$(C_PROBE_OBJ) \
		$(CORE_LIB) \
		-o $(C_PROBE_BIN)

$(COREFOUNDATION_PROBE_OBJ): $(COREFOUNDATION_PROBE_SRC) $(COREFOUNDATION_HDR) $(CORE_HDR) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-I $(CORE_INC) \
		-I $(COREFOUNDATION_INC) \
		-c $(COREFOUNDATION_PROBE_SRC) \
		-o $(COREFOUNDATION_PROBE_OBJ)

$(COREFOUNDATION_PROBE_BIN): $(COREFOUNDATION_PROBE_OBJ) $(COREFOUNDATION_LIB) $(CORE_LIB)
	$(CC) \
		-arch ppc -mmacosx-version-min=10.5 \
		$(COREFOUNDATION_PROBE_OBJ) \
		$(COREFOUNDATION_LIB) \
		$(CORE_LIB) \
		-framework CoreFoundation \
		-o $(COREFOUNDATION_PROBE_BIN)

$(FOUNDATION_PROBE_OBJ): $(FOUNDATION_PROBE_SRC) $(FOUNDATION_HDR) $(CORE_HDR) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-Wall -Wextra \
		-I $(CORE_INC) \
		-I $(FOUNDATION_INC) \
		-c $(FOUNDATION_PROBE_SRC) \
		-o $(FOUNDATION_PROBE_OBJ)

$(FOUNDATION_PROBE_BIN): $(FOUNDATION_PROBE_OBJ) $(FOUNDATION_LIB) $(CORE_LIB)
	$(CC) \
		-arch ppc -mmacosx-version-min=10.5 \
		$(FOUNDATION_PROBE_OBJ) \
		$(FOUNDATION_LIB) \
		$(CORE_LIB) \
		-framework Foundation \
		-o $(FOUNDATION_PROBE_BIN)

dist: libs
	rm -rf $(DIST_DIR)
	mkdir -p $(DIST_DIR)/include
	mkdir -p $(DIST_DIR)/lib
	cp -p $(CORE_HDR) $(DIST_DIR)/include/
	cp -p $(VERSION_HDR) $(DIST_DIR)/include/
	cp -p $(COREFOUNDATION_HDR) $(DIST_DIR)/include/
	cp -p $(FOUNDATION_HDR) $(DIST_DIR)/include/
	cp -p $(CORE_LIB) $(DIST_DIR)/lib/
	cp -p $(COREFOUNDATION_LIB) $(DIST_DIR)/lib/
	cp -p $(FOUNDATION_LIB) $(DIST_DIR)/lib/
	@echo "LeoUTF8 distribution staged in $(DIST_DIR)"

$(DISTCHECK_DIR):
	mkdir -p $(DISTCHECK_DIR)

$(CONSUMER_CORE_BIN): dist $(CONSUMER_CORE_SRC) | $(DISTCHECK_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-I $(DIST_DIR)/include \
		$(CONSUMER_CORE_SRC) \
		$(DIST_DIR)/lib/libLeoUTF8Core.a \
		-o $(CONSUMER_CORE_BIN)

$(CONSUMER_COREFOUNDATION_BIN): dist $(CONSUMER_COREFOUNDATION_SRC) | $(DISTCHECK_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-I $(DIST_DIR)/include \
		$(CONSUMER_COREFOUNDATION_SRC) \
		$(DIST_DIR)/lib/libLeoUTF8CoreFoundation.a \
		$(DIST_DIR)/lib/libLeoUTF8Core.a \
		-framework CoreFoundation \
		-o $(CONSUMER_COREFOUNDATION_BIN)

$(CONSUMER_FOUNDATION_BIN): dist $(CONSUMER_FOUNDATION_SRC) | $(DISTCHECK_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-Wall -Wextra \
		-I $(DIST_DIR)/include \
		$(CONSUMER_FOUNDATION_SRC) \
		$(DIST_DIR)/lib/libLeoUTF8Foundation.a \
		$(DIST_DIR)/lib/libLeoUTF8Core.a \
		-framework Foundation \
		-o $(CONSUMER_FOUNDATION_BIN)

distcheck: $(CONSUMER_CORE_BIN) $(CONSUMER_COREFOUNDATION_BIN) $(CONSUMER_FOUNDATION_BIN)
	$(CONSUMER_CORE_BIN)
	$(CONSUMER_COREFOUNDATION_BIN)
	$(CONSUMER_FOUNDATION_BIN)
	@echo "LeoUTF8 distcheck completed successfully."

$(HFSPLUS_PROBE_BIN): $(HFSPLUS_PROBE_SRC) $(CORE_LIB) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-I $(CORE_INC) \
		$(HFSPLUS_PROBE_SRC) \
		$(CORE_LIB) \
		-o $(HFSPLUS_PROBE_BIN)

hfscheck: $(HFSPLUS_PROBE_BIN)
	$(HFSPLUS_PROBE_BIN)

$(HFSBOUNDARY_PROBE_BIN): $(HFSBOUNDARY_PROBE_SRC) $(CORE_LIB) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-Wall -Wextra \
		-I $(CORE_INC) \
		$(HFSBOUNDARY_PROBE_SRC) \
		$(CORE_LIB) \
		-framework Foundation \
		-framework CoreFoundation \
		-o $(HFSBOUNDARY_PROBE_BIN)

hfsboundarycheck: $(HFSBOUNDARY_PROBE_BIN)
	$(HFSBOUNDARY_PROBE_BIN)

$(HFSCASE_PROBE_BIN): $(HFSCASE_PROBE_SRC) $(CORE_LIB) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-I $(CORE_INC) \
		$(HFSCASE_PROBE_SRC) \
		$(CORE_LIB) \
		-o $(HFSCASE_PROBE_BIN)

hfscasecheck: $(HFSCASE_PROBE_BIN)
	$(HFSCASE_PROBE_BIN)

$(HFSCOMPARE_PROBE_BIN): $(HFSCOMPARE_PROBE_SRC) $(CORE_LIB) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-Wall -Wextra \
		-I $(CORE_INC) \
		$(HFSCOMPARE_PROBE_SRC) \
		$(CORE_LIB) \
		-framework Foundation \
		-framework CoreFoundation \
		-o $(HFSCOMPARE_PROBE_BIN)

hfscomparecheck: $(HFSCOMPARE_PROBE_BIN)
	$(HFSCOMPARE_PROBE_BIN)

$(HFSURL_PROBE_BIN): $(HFSURL_PROBE_SRC) $(CORE_LIB) | $(BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-Wall -Wextra \
		-I $(CORE_INC) \
		$(HFSURL_PROBE_SRC) \
		$(CORE_LIB) \
		-framework Foundation \
		-framework CoreFoundation \
		-o $(HFSURL_PROBE_BIN)

hfsurlcheck: $(HFSURL_PROBE_BIN)
	$(HFSURL_PROBE_BIN)

install: libs
	mkdir -p $(DESTDIR)$(PREFIX)/include
	mkdir -p $(DESTDIR)$(PREFIX)/lib
	cp -p $(CORE_HDR) $(DESTDIR)$(PREFIX)/include/
	cp -p $(VERSION_HDR) $(DESTDIR)$(PREFIX)/include/
	cp -p $(COREFOUNDATION_HDR) $(DESTDIR)$(PREFIX)/include/
	cp -p $(FOUNDATION_HDR) $(DESTDIR)$(PREFIX)/include/
	cp -p $(CORE_LIB) $(DESTDIR)$(PREFIX)/lib/
	cp -p $(COREFOUNDATION_LIB) $(DESTDIR)$(PREFIX)/lib/
	cp -p $(FOUNDATION_LIB) $(DESTDIR)$(PREFIX)/lib/
	@echo "LeoUTF8 installed into $(DESTDIR)$(PREFIX)"

clean:
	rm -rf $(BUILD_DIR)

distclean: clean
	rm -rf dist

# External examples built against the staged dist/LeoUTF8 brick.
EXAMPLES_BUILD_DIR = $(BUILD_DIR)/examples

CORE_EXAMPLE_SRC = Examples/Core/leoutf8_core_example.c
CORE_EXAMPLE_BIN = $(EXAMPLES_BUILD_DIR)/leoutf8_core_example

COREFOUNDATION_EXAMPLE_SRC = Examples/CoreFoundation/leoutf8_corefoundation_example.c
COREFOUNDATION_EXAMPLE_BIN = $(EXAMPLES_BUILD_DIR)/leoutf8_corefoundation_example

FOUNDATION_EXAMPLE_SRC = Examples/Foundation/leoutf8_foundation_example.m
FOUNDATION_EXAMPLE_BIN = $(EXAMPLES_BUILD_DIR)/leoutf8_foundation_example

.PHONY: examples

$(EXAMPLES_BUILD_DIR):
	mkdir -p $(EXAMPLES_BUILD_DIR)

$(CORE_EXAMPLE_BIN): dist $(CORE_EXAMPLE_SRC) | $(EXAMPLES_BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-I $(DIST_DIR)/include \
		$(CORE_EXAMPLE_SRC) \
		$(DIST_DIR)/lib/libLeoUTF8Core.a \
		-o $(CORE_EXAMPLE_BIN)

$(COREFOUNDATION_EXAMPLE_BIN): dist $(COREFOUNDATION_EXAMPLE_SRC) | $(EXAMPLES_BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-I $(DIST_DIR)/include \
		$(COREFOUNDATION_EXAMPLE_SRC) \
		$(DIST_DIR)/lib/libLeoUTF8CoreFoundation.a \
		$(DIST_DIR)/lib/libLeoUTF8Core.a \
		-framework CoreFoundation \
		-o $(COREFOUNDATION_EXAMPLE_BIN)

$(FOUNDATION_EXAMPLE_BIN): dist $(FOUNDATION_EXAMPLE_SRC) | $(EXAMPLES_BUILD_DIR)
	$(CC) \
		$(COMMON_FLAGS) \
		-Wall -Wextra \
		-I $(DIST_DIR)/include \
		$(FOUNDATION_EXAMPLE_SRC) \
		$(DIST_DIR)/lib/libLeoUTF8Foundation.a \
		$(DIST_DIR)/lib/libLeoUTF8Core.a \
		-framework Foundation \
		-o $(FOUNDATION_EXAMPLE_BIN)

examples: $(CORE_EXAMPLE_BIN) $(COREFOUNDATION_EXAMPLE_BIN) $(FOUNDATION_EXAMPLE_BIN)
	$(CORE_EXAMPLE_BIN)
	$(COREFOUNDATION_EXAMPLE_BIN)
	$(FOUNDATION_EXAMPLE_BIN)
	@echo "LeoUTF8 examples completed successfully."

# Local release archive for the hardened LeoUTF8 integration brick.
RELEASE_VERSION = 0.7.2
RELEASE_NAME = LeoUTF8-$(RELEASE_VERSION)-leopard-ppc
RELEASE_ROOT = release
RELEASE_DIR = $(RELEASE_ROOT)/$(RELEASE_NAME)
RELEASE_ARCHIVE = $(RELEASE_ROOT)/$(RELEASE_NAME).tar.gz

.PHONY: release

release: examples apidocs
	rm -rf $(RELEASE_DIR)
	mkdir -p $(RELEASE_DIR)
	mkdir -p $(RELEASE_DIR)/include
	mkdir -p $(RELEASE_DIR)/lib
	mkdir -p $(RELEASE_DIR)/docs
	mkdir -p $(RELEASE_DIR)/Examples
	mkdir -p $(RELEASE_DIR)/vendor-licenses
	cp -p README.md $(RELEASE_DIR)/
	cp -p dist/LeoUTF8/include/* $(RELEASE_DIR)/include/
	cp -p dist/LeoUTF8/lib/* $(RELEASE_DIR)/lib/
	cp -R docs/* $(RELEASE_DIR)/docs/
	mkdir -p $(RELEASE_DIR)/docs/headerdoc
	cp -R $(HEADERDOC_OUTPUT)/* $(RELEASE_DIR)/docs/headerdoc/
	cp -R Examples/* $(RELEASE_DIR)/Examples/
	cp -p vendor/utf8proc/LICENSE.md $(RELEASE_DIR)/vendor-licenses/utf8proc-LICENSE.md
	rm -f $(RELEASE_ARCHIVE)
	cd $(RELEASE_ROOT) && tar -czf $(RELEASE_NAME).tar.gz $(RELEASE_NAME)
	@echo "LeoUTF8 release staged in $(RELEASE_DIR)"
	@echo "LeoUTF8 release archive: $(RELEASE_ARCHIVE)"

# Apple HeaderDoc API documentation for public LeoUTF8 headers.
HEADERDOC_TOOL = /usr/bin/headerdoc2html
HEADERDOC_GATHER = /usr/bin/gatherheaderdoc
HEADERDOC_OUTPUT = $(BUILD_DIR)/headerdoc

PUBLIC_HEADERS = \
	$(CORE_HDR) \
	$(VERSION_HDR) \
	$(COREFOUNDATION_HDR) \
	$(FOUNDATION_HDR)

.PHONY: apidocs

apidocs:
	@test -x $(HEADERDOC_TOOL) || { echo "Missing $(HEADERDOC_TOOL)"; exit 1; }
	@test -x $(HEADERDOC_GATHER) || { echo "Missing $(HEADERDOC_GATHER)"; exit 1; }
	rm -rf $(HEADERDOC_OUTPUT)
	mkdir -p $(HEADERDOC_OUTPUT)
	$(HEADERDOC_TOOL) -o $(HEADERDOC_OUTPUT) $(PUBLIC_HEADERS)
	$(HEADERDOC_GATHER) $(HEADERDOC_OUTPUT)
	@echo "LeoUTF8 HeaderDoc output staged in $(HEADERDOC_OUTPUT)"

# LeoFuzzer integration
LEOFUZZ_BIN ?= ../LeoFuzzer/bin/leofuzz
LEOFUZZ_RESULTS_DIR = results/leofuzz
LEOFUZZ_VALIDATE_SRC = Tests/leofuzz_validate_probe.c
LEOFUZZ_VALIDATE_BIN = $(BUILD_DIR)/leofuzz_validate_probe

$(LEOFUZZ_VALIDATE_BIN): $(LEOFUZZ_VALIDATE_SRC) $(CORE_HDR) $(CORE_LIB)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-I $(CORE_INC) \
		$(LEOFUZZ_VALIDATE_SRC) \
		$(CORE_LIB) \
		-o $(LEOFUZZ_VALIDATE_BIN)

leofuzz-validate-probe: $(LEOFUZZ_VALIDATE_BIN)

leofuzz-corpus-valid: leofuzz-validate-probe
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/valid
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_VALIDATE_BIN) --corpus corpus/leofuzz/valid --results $(LEOFUZZ_RESULTS_DIR)/valid
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/valid/summary.txt
	grep 'ok=5' $(LEOFUZZ_RESULTS_DIR)/valid/summary.txt
	grep 'rejected=0' $(LEOFUZZ_RESULTS_DIR)/valid/summary.txt
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/valid/runs.tsv

leofuzz-corpus-invalid: leofuzz-validate-probe
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/invalid
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_VALIDATE_BIN) --corpus corpus/leofuzz/invalid --results $(LEOFUZZ_RESULTS_DIR)/invalid
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/invalid/summary.txt
	grep 'rejected=5' $(LEOFUZZ_RESULTS_DIR)/invalid/summary.txt
	grep '^DOMAIN_REJECT' $(LEOFUZZ_RESULTS_DIR)/invalid/runs.tsv
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/invalid/runs.tsv

leofuzz-check: leofuzz-corpus-valid leofuzz-corpus-invalid

.PHONY: leofuzz-validate-probe leofuzz-corpus-valid leofuzz-corpus-invalid leofuzz-check

# LeoFuzzer transform probes
LEOFUZZ_TRANSFORM_SRC = Tests/leofuzz_transform_probe.c
LEOFUZZ_NFC_BIN = $(BUILD_DIR)/leofuzz_nfc_probe
LEOFUZZ_NFD_BIN = $(BUILD_DIR)/leofuzz_nfd_probe
LEOFUZZ_CASEFOLD_BIN = $(BUILD_DIR)/leofuzz_casefold_probe

$(LEOFUZZ_NFC_BIN): $(LEOFUZZ_TRANSFORM_SRC) $(CORE_HDR) $(CORE_LIB)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-DLEOFUZZ_TRANSFORM_NFC \
		-I $(CORE_INC) \
		$(LEOFUZZ_TRANSFORM_SRC) \
		$(CORE_LIB) \
		-o $(LEOFUZZ_NFC_BIN)

$(LEOFUZZ_NFD_BIN): $(LEOFUZZ_TRANSFORM_SRC) $(CORE_HDR) $(CORE_LIB)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-DLEOFUZZ_TRANSFORM_NFD \
		-I $(CORE_INC) \
		$(LEOFUZZ_TRANSFORM_SRC) \
		$(CORE_LIB) \
		-o $(LEOFUZZ_NFD_BIN)

$(LEOFUZZ_CASEFOLD_BIN): $(LEOFUZZ_TRANSFORM_SRC) $(CORE_HDR) $(CORE_LIB)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-DLEOFUZZ_TRANSFORM_CASEFOLD \
		-I $(CORE_INC) \
		$(LEOFUZZ_TRANSFORM_SRC) \
		$(CORE_LIB) \
		-o $(LEOFUZZ_CASEFOLD_BIN)

leofuzz-transform-probes: $(LEOFUZZ_NFC_BIN) $(LEOFUZZ_NFD_BIN) $(LEOFUZZ_CASEFOLD_BIN)

leofuzz-nfc-valid: leofuzz-transform-probes
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/nfc-valid
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_NFC_BIN) --corpus corpus/leofuzz/valid --results $(LEOFUZZ_RESULTS_DIR)/nfc-valid
	grep 'ok=5' $(LEOFUZZ_RESULTS_DIR)/nfc-valid/summary.txt
	grep 'rejected=0' $(LEOFUZZ_RESULTS_DIR)/nfc-valid/summary.txt
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/nfc-valid/summary.txt
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/nfc-valid/runs.tsv

leofuzz-nfc-invalid: leofuzz-transform-probes
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/nfc-invalid
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_NFC_BIN) --corpus corpus/leofuzz/invalid --results $(LEOFUZZ_RESULTS_DIR)/nfc-invalid
	grep 'ok=0' $(LEOFUZZ_RESULTS_DIR)/nfc-invalid/summary.txt
	grep 'rejected=5' $(LEOFUZZ_RESULTS_DIR)/nfc-invalid/summary.txt
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/nfc-invalid/summary.txt
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/nfc-invalid/runs.tsv

leofuzz-nfd-valid: leofuzz-transform-probes
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/nfd-valid
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_NFD_BIN) --corpus corpus/leofuzz/valid --results $(LEOFUZZ_RESULTS_DIR)/nfd-valid
	grep 'ok=5' $(LEOFUZZ_RESULTS_DIR)/nfd-valid/summary.txt
	grep 'rejected=0' $(LEOFUZZ_RESULTS_DIR)/nfd-valid/summary.txt
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/nfd-valid/summary.txt
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/nfd-valid/runs.tsv

leofuzz-nfd-invalid: leofuzz-transform-probes
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/nfd-invalid
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_NFD_BIN) --corpus corpus/leofuzz/invalid --results $(LEOFUZZ_RESULTS_DIR)/nfd-invalid
	grep 'ok=0' $(LEOFUZZ_RESULTS_DIR)/nfd-invalid/summary.txt
	grep 'rejected=5' $(LEOFUZZ_RESULTS_DIR)/nfd-invalid/summary.txt
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/nfd-invalid/summary.txt
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/nfd-invalid/runs.tsv

leofuzz-casefold-valid: leofuzz-transform-probes
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/casefold-valid
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_CASEFOLD_BIN) --corpus corpus/leofuzz/valid --results $(LEOFUZZ_RESULTS_DIR)/casefold-valid
	grep 'ok=5' $(LEOFUZZ_RESULTS_DIR)/casefold-valid/summary.txt
	grep 'rejected=0' $(LEOFUZZ_RESULTS_DIR)/casefold-valid/summary.txt
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/casefold-valid/summary.txt
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/casefold-valid/runs.tsv

leofuzz-casefold-invalid: leofuzz-transform-probes
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/casefold-invalid
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_CASEFOLD_BIN) --corpus corpus/leofuzz/invalid --results $(LEOFUZZ_RESULTS_DIR)/casefold-invalid
	grep 'ok=0' $(LEOFUZZ_RESULTS_DIR)/casefold-invalid/summary.txt
	grep 'rejected=5' $(LEOFUZZ_RESULTS_DIR)/casefold-invalid/summary.txt
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/casefold-invalid/summary.txt
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/casefold-invalid/runs.tsv

leofuzz-transform-check: \
	leofuzz-nfc-valid \
	leofuzz-nfc-invalid \
	leofuzz-nfd-valid \
	leofuzz-nfd-invalid \
	leofuzz-casefold-valid \
	leofuzz-casefold-invalid

.PHONY: leofuzz-transform-probes leofuzz-nfc-valid leofuzz-nfc-invalid leofuzz-nfd-valid leofuzz-nfd-invalid leofuzz-casefold-valid leofuzz-casefold-invalid leofuzz-transform-check

# LeoFuzzer transform expectation probes
LEOFUZZ_TRANSFORM_EXPECT_SRC = Tests/leofuzz_transform_expect_probe.c
LEOFUZZ_NFC_EXPECT_BIN = $(BUILD_DIR)/leofuzz_nfc_expect_probe
LEOFUZZ_NFD_EXPECT_BIN = $(BUILD_DIR)/leofuzz_nfd_expect_probe
LEOFUZZ_CASEFOLD_EXPECT_BIN = $(BUILD_DIR)/leofuzz_casefold_expect_probe

$(LEOFUZZ_NFC_EXPECT_BIN): $(LEOFUZZ_TRANSFORM_EXPECT_SRC) $(CORE_HDR) $(CORE_LIB)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-DLEOFUZZ_TRANSFORM_NFC \
		-I $(CORE_INC) \
		$(LEOFUZZ_TRANSFORM_EXPECT_SRC) \
		$(CORE_LIB) \
		-o $(LEOFUZZ_NFC_EXPECT_BIN)

$(LEOFUZZ_NFD_EXPECT_BIN): $(LEOFUZZ_TRANSFORM_EXPECT_SRC) $(CORE_HDR) $(CORE_LIB)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-DLEOFUZZ_TRANSFORM_NFD \
		-I $(CORE_INC) \
		$(LEOFUZZ_TRANSFORM_EXPECT_SRC) \
		$(CORE_LIB) \
		-o $(LEOFUZZ_NFD_EXPECT_BIN)

$(LEOFUZZ_CASEFOLD_EXPECT_BIN): $(LEOFUZZ_TRANSFORM_EXPECT_SRC) $(CORE_HDR) $(CORE_LIB)
	$(CC) \
		$(COMMON_FLAGS) \
		-std=c99 \
		-Wall -Wextra -pedantic \
		-DLEOFUZZ_TRANSFORM_CASEFOLD \
		-I $(CORE_INC) \
		$(LEOFUZZ_TRANSFORM_EXPECT_SRC) \
		$(CORE_LIB) \
		-o $(LEOFUZZ_CASEFOLD_EXPECT_BIN)

leofuzz-transform-expect-probes: $(LEOFUZZ_NFC_EXPECT_BIN) $(LEOFUZZ_NFD_EXPECT_BIN) $(LEOFUZZ_CASEFOLD_EXPECT_BIN)

leofuzz-nfc-expect: leofuzz-transform-expect-probes
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/nfc-expect
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_NFC_EXPECT_BIN) --corpus corpus/leofuzz/expect/nfc --results $(LEOFUZZ_RESULTS_DIR)/nfc-expect
	grep 'runs=1' $(LEOFUZZ_RESULTS_DIR)/nfc-expect/summary.txt
	grep 'ok=1' $(LEOFUZZ_RESULTS_DIR)/nfc-expect/summary.txt
	grep 'rejected=0' $(LEOFUZZ_RESULTS_DIR)/nfc-expect/summary.txt
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/nfc-expect/summary.txt
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/nfc-expect/runs.tsv

leofuzz-nfd-expect: leofuzz-transform-expect-probes
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/nfd-expect
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_NFD_EXPECT_BIN) --corpus corpus/leofuzz/expect/nfd --results $(LEOFUZZ_RESULTS_DIR)/nfd-expect
	grep 'runs=1' $(LEOFUZZ_RESULTS_DIR)/nfd-expect/summary.txt
	grep 'ok=1' $(LEOFUZZ_RESULTS_DIR)/nfd-expect/summary.txt
	grep 'rejected=0' $(LEOFUZZ_RESULTS_DIR)/nfd-expect/summary.txt
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/nfd-expect/summary.txt
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/nfd-expect/runs.tsv

leofuzz-casefold-expect: leofuzz-transform-expect-probes
	test -x $(LEOFUZZ_BIN)
	rm -rf $(LEOFUZZ_RESULTS_DIR)/casefold-expect
	$(LEOFUZZ_BIN) --target $(LEOFUZZ_CASEFOLD_EXPECT_BIN) --corpus corpus/leofuzz/expect/casefold --results $(LEOFUZZ_RESULTS_DIR)/casefold-expect
	grep 'runs=1' $(LEOFUZZ_RESULTS_DIR)/casefold-expect/summary.txt
	grep 'ok=1' $(LEOFUZZ_RESULTS_DIR)/casefold-expect/summary.txt
	grep 'rejected=0' $(LEOFUZZ_RESULTS_DIR)/casefold-expect/summary.txt
	grep 'findings=0' $(LEOFUZZ_RESULTS_DIR)/casefold-expect/summary.txt
	awk -F '\t' 'NR > 1 { if (NF != 7) exit 1 }' $(LEOFUZZ_RESULTS_DIR)/casefold-expect/runs.tsv

leofuzz-transform-expect-check: \
	leofuzz-nfc-expect \
	leofuzz-nfd-expect \
	leofuzz-casefold-expect

.PHONY: leofuzz-transform-expect-probes leofuzz-nfc-expect leofuzz-nfd-expect leofuzz-casefold-expect leofuzz-transform-expect-check