mittens 0.2.0 → 0.3.0

data/vendor/snowball/GNUmakefile

@@ -2,7 +2,7 @@
 
 # After changing this, run `make update_version` to update various sources
 # which hard-code it.
-SNOWBALL_VERSION = 2.2.0
+SNOWBALL_VERSION = 3.0.1
 
 ifeq ($(OS),Windows_NT)
 EXEEXT = .exe
@@ -10,8 +10,9 @@ endif
 
 c_src_dir = src_c
 
+JAVACFLAGS ?=
 JAVAC ?= javac
-JAVA ?= java
+JAVA ?= java -ea
 java_src_main_dir = java/org/tartarus/snowball
 java_src_dir = $(java_src_main_dir)/ext
 
@@ -22,6 +23,8 @@ csharp_src_dir = $(csharp_src_main_dir)/Algorithms
 csharp_sample_dir = csharp/Stemwords
 
 FPC ?= fpc
+# Enable warnings, info, notes; select "FILE:LINE:" diagnostic format.
+FPC_FLAGS ?= -veiwnr
 pascal_src_dir = pascal
 
 python ?= python3
@@ -32,7 +35,8 @@ python_sample_dir = sample
 js_output_dir = js_out
 js_runtime_dir = javascript
 js_sample_dir = sample
-NODE ?= nodejs
+JSRUN ?= node
+JSTYPE ?= global
 
 cargo ?= cargo
 cargoflags ?= --release
@@ -56,6 +60,22 @@ endif
 ICONV = iconv
 #ICONV = python ./iconv.py
 
+# Where the data files are located - assumes their repo is checked out as
+# a sibling to this one.
+STEMMING_DATA ?= ../snowball-data
+STEMMING_DATA_ABS := $(abspath $(STEMMING_DATA))
+
+# Keep one in $(THIN_FACTOR) entries from gzipped vocabularies.
+THIN_FACTOR ?= 3
+
+ifneq (1,$(THIN_FACTOR))
+ifneq (,$(THIN_FACTOR))
+# Command to thin out the testdata.  Used for Python tests, which otherwise
+# take a long time (unless you use pypy).
+THIN_TEST_DATA := |awk '(FNR % $(THIN_FACTOR) == 0){print}'
+endif
+endif
+
 tarball_ext = .tar.gz
 
 # algorithms.mk is generated from libstemmer/modules.txt and defines:
@@ -65,7 +85,7 @@ tarball_ext = .tar.gz
 # * KOI8_R_algorithms
 include algorithms.mk
 
-other_algorithms = german2 kraaij_pohlmann lovins
+other_algorithms = lovins
 
 all_algorithms = $(libstemmer_algorithms) $(other_algorithms)
 
@@ -84,8 +104,7 @@ COMPILER_SOURCES = compiler/space.c \
 		   compiler/generator_ada.c
 
 COMPILER_HEADERS = compiler/header.h \
-		   compiler/syswords.h \
-		   compiler/syswords2.h
+		   compiler/syswords.h
 
 RUNTIME_SOURCES  = runtime/api.c \
 		   runtime/utilities.c
@@ -151,7 +170,8 @@ CSHARP_SOURCES = $(libstemmer_algorithms:%=$(csharp_src_dir)/%Stemmer.generated.
 PASCAL_SOURCES = $(ISO_8859_1_algorithms:%=$(pascal_src_dir)/%Stemmer.pas)
 PYTHON_SOURCES = $(libstemmer_algorithms:%=$(python_output_dir)/%_stemmer.py) \
 		 $(python_output_dir)/__init__.py
-JS_SOURCES = $(libstemmer_algorithms:%=$(js_output_dir)/%-stemmer.js)
+JS_SOURCES = $(libstemmer_algorithms:%=$(js_output_dir)/%-stemmer.js) \
+	$(js_output_dir)/base-stemmer.js
 RUST_SOURCES = $(libstemmer_algorithms:%=$(rust_src_dir)/%_stemmer.rs)
 GO_SOURCES = $(libstemmer_algorithms:%=$(go_src_dir)/%_stemmer.go) \
 	$(go_src_main_dir)/stemwords/algorithms.go
@@ -170,7 +190,7 @@ C_OTHER_OBJECTS = $(C_OTHER_SOURCES:.c=.o)
 JAVA_CLASSES = $(JAVA_SOURCES:.java=.class)
 JAVA_RUNTIME_CLASSES=$(JAVARUNTIME_SOURCES:.java=.class)
 
-CFLAGS=-O2 -W -Wall -Wmissing-prototypes -Wmissing-declarations
+CFLAGS=-g -O2 -W -Wall -Wmissing-prototypes -Wmissing-declarations -Wshadow $(WERROR)
 CPPFLAGS=
 
 INCLUDES=-Iinclude
@@ -195,6 +215,7 @@ clean:
 	      $(JS_SOURCES) \
 	      $(RUST_SOURCES) \
 	      $(ADA_SOURCES) ada/bin/generate ada/bin/stemwords \
+	      stemtest$(EXEEXT) $(STEMTEST_OBJECTS) \
               libstemmer/mkinc.mak libstemmer/mkinc_utf8.mak \
               libstemmer/libstemmer.c libstemmer/libstemmer_utf8.c \
 	      algorithms.mk
@@ -203,6 +224,17 @@ clean:
 	-rmdir $(python_output_dir)
 	-rmdir $(js_output_dir)
 
+update_version:
+	perl -pi -e 's/(SNOWBALL_VERSION.*?)\d+\.\d+\.\d+/$${1}$(SNOWBALL_VERSION)/' \
+		compiler/header.h \
+		csharp/Snowball/AssemblyInfo.cs \
+		python/setup.py
+
+.PHONY: all clean update_version
+
+$(STEMMING_DATA)/% $(STEMMING_DATA_ABS)/%:
+	@[ -f '$@' ] || { echo '$@: Test data not found'; echo 'Checkout the snowball-data repo as "$(STEMMING_DATA_ABS)"'; exit 1; }
+
 snowball$(EXEEXT): $(COMPILER_OBJECTS)
 	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^
 
@@ -244,110 +276,72 @@ pascal/stemwords.dpr: pascal/stemwords-template.dpr libstemmer/modules.txt
 	pascal/generate.pl $(ISO_8859_1_algorithms) < pascal/stemwords-template.dpr > $@
 
 pascal/stemwords: $(PASCAL_STEMWORDS_SOURCES) $(PASCAL_RUNTIME_SOURCES) $(PASCAL_SOURCES)
-	$(FPC) -o$@ -Mdelphi $(PASCAL_STEMWORDS_SOURCES)
+	$(FPC) $(FPC_FLAGS) -o$@ -Mdelphi $(PASCAL_STEMWORDS_SOURCES)
 
 $(c_src_dir)/stem_UTF_8_%.c $(c_src_dir)/stem_UTF_8_%.h: algorithms/%.sbl snowball$(EXEEXT)
 	@mkdir -p $(c_src_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(c_src_dir)/stem_UTF_8_$${l}"; \
-	echo "./snowball $< -o $${o} -eprefix $${l}_UTF_8_ -r ../runtime -u"; \
-	./snowball $< -o $${o} -eprefix $${l}_UTF_8_ -r ../runtime -u
+	./snowball $< -o "$(c_src_dir)/stem_UTF_8_$*" -eprefix $*_UTF_8_ -r ../runtime -u
 
 $(c_src_dir)/stem_KOI8_R_%.c $(c_src_dir)/stem_KOI8_R_%.h: algorithms/%.sbl snowball$(EXEEXT)
 	@mkdir -p $(c_src_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(c_src_dir)/stem_KOI8_R_$${l}"; \
-	echo "./snowball charsets/KOI8-R.sbl $< -o $${o} -eprefix $${l}_KOI8_R_ -r ../runtime"; \
-	./snowball charsets/KOI8-R.sbl $< -o $${o} -eprefix $${l}_KOI8_R_ -r ../runtime
+	./snowball charsets/KOI8-R.sbl $< -o "$(c_src_dir)/stem_KOI8_R_$*" -eprefix $*_KOI8_R_ -r ../runtime
 
 $(c_src_dir)/stem_ISO_8859_1_%.c $(c_src_dir)/stem_ISO_8859_1_%.h: algorithms/%.sbl snowball$(EXEEXT)
 	@mkdir -p $(c_src_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(c_src_dir)/stem_ISO_8859_1_$${l}"; \
-	echo "./snowball $< -o $${o} -eprefix $${l}_ISO_8859_1_ -r ../runtime"; \
-	./snowball $< -o $${o} -eprefix $${l}_ISO_8859_1_ -r ../runtime
+	./snowball $< -o "$(c_src_dir)/stem_ISO_8859_1_$*" -eprefix $*_ISO_8859_1_ -r ../runtime
 
 $(c_src_dir)/stem_ISO_8859_2_%.c $(c_src_dir)/stem_ISO_8859_2_%.h: algorithms/%.sbl snowball$(EXEEXT)
 	@mkdir -p $(c_src_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(c_src_dir)/stem_ISO_8859_2_$${l}"; \
-	echo "./snowball charsets/ISO-8859-2.sbl $< -o $${o} -eprefix $${l}_ISO_8859_2_ -r ../runtime"; \
-	./snowball charsets/ISO-8859-2.sbl $< -o $${o} -eprefix $${l}_ISO_8859_2_ -r ../runtime
+	./snowball charsets/ISO-8859-2.sbl $< -o "$(c_src_dir)/stem_ISO_8859_2_$*" -eprefix $*_ISO_8859_2_ -r ../runtime
 
 $(c_src_dir)/stem_%.o: $(c_src_dir)/stem_%.c $(c_src_dir)/stem_%.h
 	$(CC) $(CFLAGS) $(INCLUDES) $(CPPFLAGS) -c -o $@ $<
 
 $(java_src_dir)/%Stemmer.java: algorithms/%.sbl snowball$(EXEEXT)
 	@mkdir -p $(java_src_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(java_src_dir)/$${l}Stemmer"; \
-	echo "./snowball $< -j -o $${o} -p org.tartarus.snowball.SnowballStemmer"; \
-	./snowball $< -j -o $${o} -p org.tartarus.snowball.SnowballStemmer
+	./snowball $< -j -o "$(java_src_dir)/$*Stemmer" -p org.tartarus.snowball.SnowballStemmer
 
 $(csharp_src_dir)/%Stemmer.generated.cs: algorithms/%.sbl snowball$(EXEEXT)
 	@mkdir -p $(csharp_src_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	t=`echo "$${l}" | sed 's/.*/\L&/; s/[a-z]*/\u&/g'`; \
-	o="$(csharp_src_dir)/$${l}Stemmer.generated"; \
-	echo "./snowball $< -cs -o $${o}"; \
-	./snowball $< -cs -o $${o}
+	./snowball $< -cs -o "$(csharp_src_dir)/$*Stemmer.generated"
 
 $(pascal_src_dir)/%Stemmer.pas: algorithms/%.sbl snowball$(EXEEXT)
 	@mkdir -p $(pascal_src_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	t=`echo "$${l}" | sed 's/.*/\L&/; s/[a-z]*/\u&/g'`; \
-	o="$(pascal_src_dir)/$${l}Stemmer"; \
-	echo "./snowball $< -pascal -o $${o}"; \
-	./snowball $< -pascal -o $${o}
+	./snowball $< -pascal -o "$(pascal_src_dir)/$*Stemmer"
 
 $(python_output_dir)/%_stemmer.py: algorithms/%.sbl snowball$(EXEEXT)
 	@mkdir -p $(python_output_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(python_output_dir)/$${l}_stemmer"; \
-	echo "./snowball $< -py -o $${o}"; \
-	./snowball $< -py -o $${o}
+	./snowball $< -py -o "$(python_output_dir)/$*_stemmer"
 
-$(python_output_dir)/__init__.py: libstemmer/modules.txt
-	@mkdir -p $(python_output_dir)
+$(python_output_dir)/__init__.py: $(libstemmer_algorithms:%=$(python_output_dir)/%_stemmer.py)
 	$(python) python/create_init.py $(python_output_dir)
 
 $(rust_src_dir)/%_stemmer.rs: algorithms/%.sbl snowball$(EXEEXT)
 	@mkdir -p $(rust_src_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(rust_src_dir)/$${l}_stemmer"; \
-	echo "./snowball $< -rust -o $${o}"; \
-	./snowball $< -rust -o $${o}
+	./snowball $< -rust -o "$(rust_src_dir)/$*_stemmer"
 
 $(go_src_main_dir)/stemwords/algorithms.go: go/stemwords/generate.go libstemmer/modules.txt
 	@echo "Generating algorithms.go"
 	@cd go/stemwords && go generate
 
 $(go_src_dir)/%_stemmer.go: algorithms/%.sbl snowball$(EXEEXT)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(go_src_dir)/$${l}/$${l}_stemmer"; \
-	mkdir -p $(go_src_dir)/$${l}
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(go_src_dir)/$${l}/$${l}_stemmer"; \
-	echo "./snowball $< -go -o $${o} -gop $${l}"; \
-	./snowball $< -go -o $${o} -gop $${l}
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(go_src_dir)/$${l}/$${l}_stemmer"; \
-	echo "$(gofmt) -s -w $(go_src_dir)/$${l}/$${l}_stemmer.go"; \
-	$(gofmt) -s -w $(go_src_dir)/$${l}/$${l}_stemmer.go
+	@mkdir -p $(go_src_dir)/$*
+	./snowball $< -go -o "$(go_src_dir)/$*/$*_stemmer" -gop $*
+	$(gofmt) -s -w $(go_src_dir)/$*/$*_stemmer.go
 
 $(js_output_dir)/%-stemmer.js: algorithms/%.sbl snowball$(EXEEXT)
 	@mkdir -p $(js_output_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(js_output_dir)/$${l}-stemmer"; \
-	echo "./snowball $< -js -o $${o}"; \
-	./snowball $< -js -o $${o}
+	./snowball $< -js -o "$(js_output_dir)/$*-stemmer"
+
+$(js_output_dir)/base-stemmer.js: $(js_runtime_dir)/base-stemmer.js
+	@mkdir -p $(js_output_dir)
+	cp $< $@
 
 $(ada_src_dir)/stemmer-%.ads: algorithms/%.sbl snowball
 	@mkdir -p $(ada_src_dir)
-	@l=`echo "$<" | sed 's!\(.*\)\.sbl$$!\1!;s!^.*/!!'`; \
-	o="$(ada_src_dir)/stemmer-$${l}"; \
-	echo "./snowball $< -ada -o $${o}"; \
-	./snowball $< -ada -P $${l} -o $${o}
+	./snowball $< -ada -P $* -o "$(ada_src_dir)/stemmer-$*"
+
+.PHONY: dist dist_snowball dist_libstemmer_c dist_libstemmer_csharp dist_libstemmer_java dist_libstemmer_js dist_libstemmer_python
 
 # Make a full source distribution
 dist: dist_snowball dist_libstemmer_c dist_libstemmer_csharp dist_libstemmer_java dist_libstemmer_js dist_libstemmer_python
@@ -384,6 +378,7 @@ dist_libstemmer_c: \
             $(LIBSTEMMER_EXTRA) \
 	    $(C_LIB_SOURCES) \
             $(C_LIB_HEADERS) \
+	    $(COMMON_FILES) \
             libstemmer/mkinc.mak \
             libstemmer/mkinc_utf8.mak
 	destname=libstemmer_c-$(SNOWBALL_VERSION); \
@@ -428,6 +423,7 @@ dist_libstemmer_c: \
 
 # Make a distribution of all the sources required to compile the Java library.
 dist_libstemmer_java: $(RUNTIME_SOURCES) $(RUNTIME_HEADERS) \
+	    $(COMMON_FILES) \
             $(LIBSTEMMER_EXTRA) \
 	    $(JAVA_SOURCES)
 	destname=libstemmer_java-$(SNOWBALL_VERSION); \
@@ -450,6 +446,7 @@ dist_libstemmer_java: $(RUNTIME_SOURCES) $(RUNTIME_HEADERS) \
 
 # Make a distribution of all the sources required to compile the C# library.
 dist_libstemmer_csharp: $(RUNTIME_SOURCES) $(RUNTIME_HEADERS) \
+	    $(COMMON_FILES) \
             $(LIBSTEMMER_EXTRA) \
 	    $(CSHARP_SOURCES)
 	destname=libstemmer_csharp-$(SNOWBALL_VERSION); \
@@ -468,7 +465,7 @@ dist_libstemmer_csharp: $(RUNTIME_SOURCES) $(RUNTIME_HEADERS) \
 	(cd dist && tar zcf $${destname}$(tarball_ext) $${destname}) && \
 	rm -rf $${dest}
 
-dist_libstemmer_python: $(PYTHON_SOURCES)
+dist_libstemmer_python: $(PYTHON_SOURCES) $(COMMON_FILES)
 	destname=snowballstemmer-$(SNOWBALL_VERSION); \
 	dest=dist/$${destname}; \
 	rm -rf $${dest} && \
@@ -482,10 +479,10 @@ dist_libstemmer_python: $(PYTHON_SOURCES)
 	cp -a $(PYTHON_SAMPLE_SOURCES) $${dest}/src/$(python_sample_dir) && \
 	cp -a $(PYTHON_RUNTIME_SOURCES) $${dest}/src/$(python_runtime_dir) && \
 	cp -a $(COMMON_FILES) $(PYTHON_PACKAGE_FILES) $${dest} && \
-	(cd $${dest} && $(python) setup.py sdist bdist_wheel && cp dist/*.tar.gz dist/*.whl ..) && \
+	(cd $${dest} && $(python) -m build && cp dist/*.tar.gz dist/*.whl ..) && \
 	rm -rf $${dest}
 
-dist_libstemmer_js: $(JS_SOURCES)
+dist_libstemmer_js: $(JS_SOURCES) $(COMMON_FILES)
 	destname=jsstemmer-$(SNOWBALL_VERSION); \
 	dest=dist/$${destname}; \
 	rm -rf $${dest} && \
@@ -503,6 +500,12 @@ dist_libstemmer_js: $(JS_SOURCES)
 	(cd dist && tar zcf $${destname}$(tarball_ext) $${destname}) && \
 	rm -rf $${dest}
 
+###############################################################################
+# C
+###############################################################################
+
+.PHONY: check check_stemtest check_utf8 check_iso_8859_1 check_iso_8859_2 check_koi8r
+
 check: check_stemtest check_utf8 check_iso_8859_1 check_iso_8859_2 check_koi8r
 
 check_stemtest: stemtest$(EXEEXT)
@@ -516,17 +519,12 @@ check_iso_8859_2: $(ISO_8859_2_algorithms:%=check_iso_8859_2_%)
 
 check_koi8r: $(KOI8_R_algorithms:%=check_koi8r_%)
 
-# Where the data files are located - assumes their repo is checked out as
-# a sibling to this one.
-STEMMING_DATA ?= ../snowball-data
-STEMMING_DATA_ABS := $(abspath $(STEMMING_DATA))
-
 check_utf8_%: $(STEMMING_DATA)/% stemwords$(EXEEXT)
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer with UTF-8"
+	@echo "Checking output of $* stemmer with UTF-8"
 	@if test -f '$</voc.txt.gz' ; then \
-	  gzip -dc '$</voc.txt.gz'|./stemwords$(EXEEXT) -c UTF_8 -l `echo $<|sed 's!.*/!!'` -o tmp.txt; \
+	  gzip -dc '$</voc.txt.gz'|./stemwords$(EXEEXT) -c UTF_8 -l $* -o tmp.txt; \
 	else \
-	  ./stemwords$(EXEEXT) -c UTF_8 -l `echo $<|sed 's!.*/!!'` -i $</voc.txt -o tmp.txt; \
+	  ./stemwords$(EXEEXT) -c UTF_8 -l $* -i $</voc.txt -o tmp.txt; \
 	fi
 	@if test -f '$</output.txt.gz' ; then \
 	  gzip -dc '$</output.txt.gz'|$(DIFF) -u - tmp.txt; \
@@ -536,44 +534,52 @@ check_utf8_%: $(STEMMING_DATA)/% stemwords$(EXEEXT)
 	@rm tmp.txt
 
 check_iso_8859_1_%: $(STEMMING_DATA)/% stemwords$(EXEEXT)
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer with ISO_8859_1"
+	@echo "Checking output of $* stemmer with ISO_8859_1"
 	@$(ICONV) -f UTF-8 -t ISO-8859-1 '$</voc.txt' |\
-	    ./stemwords -c ISO_8859_1 -l `echo $<|sed 's!.*/!!'` -o tmp.txt
+	    ./stemwords -c ISO_8859_1 -l $* -o tmp.txt
 	@$(ICONV) -f UTF-8 -t ISO-8859-1 '$</output.txt' |\
 	    $(DIFF) -u - tmp.txt
 	@rm tmp.txt
 
 check_iso_8859_2_%: $(STEMMING_DATA)/% stemwords$(EXEEXT)
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer with ISO_8859_2"
+	@echo "Checking output of $* stemmer with ISO_8859_2"
 	@$(ICONV) -f UTF-8 -t ISO-8859-2 '$</voc.txt' |\
-	    ./stemwords -c ISO_8859_2 -l `echo $<|sed 's!.*/!!'` -o tmp.txt
+	    ./stemwords -c ISO_8859_2 -l $* -o tmp.txt
 	@$(ICONV) -f UTF-8 -t ISO-8859-2 '$</output.txt' |\
 	    $(DIFF) -u - tmp.txt
 	@rm tmp.txt
 
 check_koi8r_%: $(STEMMING_DATA)/% stemwords$(EXEEXT)
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer with KOI8R"
+	@echo "Checking output of $* stemmer with KOI8R"
 	@$(ICONV) -f UTF-8 -t KOI8-R '$</voc.txt' |\
-	    ./stemwords -c KOI8_R -l `echo $<|sed 's!.*/!!'` -o tmp.txt
+	    ./stemwords -c KOI8_R -l $* -o tmp.txt
 	@$(ICONV) -f UTF-8 -t KOI8-R '$</output.txt' |\
 	    $(DIFF) -u - tmp.txt
 	@rm tmp.txt
 
+###############################################################################
+# Java
+###############################################################################
+
+.PHONY: java check_java do_check_java
+
+java: $(JAVA_CLASSES) $(JAVA_RUNTIME_CLASSES)
+
 .java.class:
-	cd java && $(JAVAC) `echo "$<"|sed 's,^java/,,'`
+	cd java && $(JAVAC) $(JAVACFLAGS) $(patsubst java/%,%,$<)
 
-check_java: $(JAVA_CLASSES) $(JAVA_RUNTIME_CLASSES)
+check_java: java
 	$(MAKE) do_check_java
 
 do_check_java: $(libstemmer_algorithms:%=check_java_%)
 
 check_java_%: $(STEMMING_DATA_ABS)/%
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer for Java"
+	@echo "Checking output of $* stemmer for Java"
 	@cd java && if test -f '$</voc.txt.gz' ; then \
 	  gzip -dc '$</voc.txt.gz' |\
-	    $(JAVA) org/tartarus/snowball/TestApp `echo $<|sed 's!.*/!!'` -o $(PWD)/tmp.txt; \
+	    $(JAVA) org/tartarus/snowball/TestApp $* -o $(PWD)/tmp.txt; \
 	else \
-	  $(JAVA) org/tartarus/snowball/TestApp `echo $<|sed 's!.*/!!'` $</voc.txt -o $(PWD)/tmp.txt; \
+	  $(JAVA) org/tartarus/snowball/TestApp $* $</voc.txt -o $(PWD)/tmp.txt; \
 	fi
 	@if test -f '$</output.txt.gz' ; then \
 	  gzip -dc '$</output.txt.gz'|$(DIFF) -u - tmp.txt; \
@@ -582,18 +588,26 @@ check_java_%: $(STEMMING_DATA_ABS)/%
 	fi
 	@rm tmp.txt
 
-check_csharp: csharp_stemwords$(EXEEXT)
+###############################################################################
+# C#
+###############################################################################
+
+.PHONY: csharp check_csharp do_check_csharp
+
+csharp: csharp_stemwords$(EXEEXT)
+
+check_csharp: csharp
 	$(MAKE) do_check_csharp
 
 do_check_csharp: $(libstemmer_algorithms:%=check_csharp_%)
 
 check_csharp_%: $(STEMMING_DATA_ABS)/%
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer for C#"
+	@echo "Checking output of $* stemmer for C#"
 	@if test -f '$</voc.txt.gz' ; then \
 	  gzip -dc '$</voc.txt.gz' |\
-	    $(MONO) csharp_stemwords$(EXEEXT) -l `echo $<|sed 's!.*/!!'` -i /dev/stdin -o tmp.txt; \
+	    $(MONO) csharp_stemwords$(EXEEXT) -l $* -i /dev/stdin -o tmp.txt; \
 	else \
-	  $(MONO) csharp_stemwords$(EXEEXT) -l `echo $<|sed 's!.*/!!'` -i $</voc.txt -o tmp.txt; \
+	  $(MONO) csharp_stemwords$(EXEEXT) -l $* -i $</voc.txt -o tmp.txt; \
 	fi
 	@if test -f '$</output.txt.gz' ; then \
 	  gzip -dc '$</output.txt.gz'|$(DIFF) -u - tmp.txt; \
@@ -602,38 +616,49 @@ check_csharp_%: $(STEMMING_DATA_ABS)/%
 	fi
 	@rm tmp.txt
 
-check_pascal: pascal/stemwords
+###############################################################################
+# Pascal
+###############################################################################
+
+.PHONY: pascal check_pascal do_check_pascal
+
+pascal: pascal/stemwords
+
+check_pascal: pascal
 	$(MAKE) do_check_pascal
 
 do_check_pascal: $(ISO_8859_1_algorithms:%=check_pascal_%)
 
 check_pascal_%: $(STEMMING_DATA_ABS)/%
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer with ISO_8859_1 for Pascal"
+	@echo "Checking output of $* stemmer with ISO_8859_1 for Pascal"
 	@$(ICONV) -f UTF-8 -t ISO-8859-1 '$</voc.txt' |\
-	    ./pascal/stemwords -l `echo $<|sed 's!.*/!!'` > tmp.txt
+	    ./pascal/stemwords -l $* > tmp.txt
 	@$(ICONV) -f UTF-8 -t ISO-8859-1 '$</output.txt' |\
 	    $(DIFF) -u - tmp.txt
 	@rm tmp.txt
 
-check_js: $(JS_SOURCES) $(libstemmer_algorithms:%=check_js_%)
+###############################################################################
+# Javascript
+###############################################################################
 
-# Keep one in $(THIN_FACTOR) entries from gzipped vocabularies.
-THIN_FACTOR ?= 3
+.PHONY: js check_js do_check_js
 
-# Command to thin out the testdata.  Used for Python tests, which otherwise
-# take a long time (unless you use pypy).
-THIN_TEST_DATA := awk '(FNR % $(THIN_FACTOR) == 0){print}'
+js: $(JS_SOURCES)
 
-check_rust: $(RUST_SOURCES) $(libstemmer_algorithms:%=check_rust_%)
+check_js: js
+	$(MAKE) do_check_js
 
-check_rust_%: $(STEMMING_DATA_ABS)/%
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer for Rust"
-	@cd rust && if test -f '$</voc.txt.gz' ; then \
+do_check_js: $(libstemmer_algorithms:%=check_js_%)
+
+check_js_%: export NODE_PATH=$(js_output_dir)
+check_js_%: $(STEMMING_DATA)/%
+	@echo "Checking output of $* stemmer for JS"
+	@if test -f '$</voc.txt.gz' ; then \
 	  gzip -dc '$</voc.txt.gz' > tmp.in; \
-	  $(cargo) run $(cargoflags) -- -l `echo $<|sed 's!.*/!!'` -i tmp.in -o $(PWD)/tmp.txt; \
+	  $(JSRUN) javascript/stemwords.js -l $* -i tmp.in -o tmp.txt; \
 	  rm tmp.in; \
 	else \
-	  $(cargo) run $(cargoflags) -- -l `echo $<|sed 's!.*/!!'` -i $</voc.txt -o $(PWD)/tmp.txt; \
+	  $(JSRUN) javascript/stemwords.js -l $* -i $</voc.txt -o tmp.txt; \
 	fi
 	@if test -f '$</output.txt.gz' ; then \
 	  gzip -dc '$</output.txt.gz'|$(DIFF) -u - tmp.txt; \
@@ -642,16 +667,27 @@ check_rust_%: $(STEMMING_DATA_ABS)/%
 	fi
 	@rm tmp.txt
 
-check_go: $(GO_SOURCES) $(libstemmer_algorithms:%=check_go_%)
+###############################################################################
+# Rust
+###############################################################################
 
-check_go_%: $(STEMMING_DATA_ABS)/%
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer for Go"
-	@cd go && if test -f '$</voc.txt.gz' ; then \
+.PHONY: rust check_rust do_check_rust
+
+rust: $(RUST_SOURCES)
+
+check_rust: rust
+	$(MAKE) do_check_rust
+
+do_check_rust: $(libstemmer_algorithms:%=check_rust_%)
+
+check_rust_%: $(STEMMING_DATA_ABS)/%
+	@echo "Checking output of $* stemmer for Rust"
+	@cd rust && if test -f '$</voc.txt.gz' ; then \
 	  gzip -dc '$</voc.txt.gz' > tmp.in; \
-	  $(go) run $(goflags) -l `echo $<|sed 's!.*/!!'` -i tmp.in -o $(PWD)/tmp.txt; \
+	  $(cargo) run $(cargoflags) -- -l $* -i tmp.in -o $(PWD)/tmp.txt; \
 	  rm tmp.in; \
 	else \
-	  $(go) run $(goflags) -l `echo $<|sed 's!.*/!!'` -i $</voc.txt -o $(PWD)/tmp.txt; \
+	  $(cargo) run $(cargoflags) -- -l $* -i $</voc.txt -o $(PWD)/tmp.txt; \
 	fi
 	@if test -f '$</output.txt.gz' ; then \
 	  gzip -dc '$</output.txt.gz'|$(DIFF) -u - tmp.txt; \
@@ -660,16 +696,27 @@ check_go_%: $(STEMMING_DATA_ABS)/%
 	fi
 	@rm tmp.txt
 
-export NODE_PATH = $(js_runtime_dir):$(js_output_dir)
+###############################################################################
+# Go
+###############################################################################
 
-check_js_%: $(STEMMING_DATA)/%
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer for JS"
-	@if test -f '$</voc.txt.gz' ; then \
+.PHONY: go check_go do_check_go
+
+go: $(GO_SOURCES)
+
+check_go: go
+	$(MAKE) do_check_go
+
+do_check_go: $(libstemmer_algorithms:%=check_go_%)
+
+check_go_%: $(STEMMING_DATA_ABS)/%
+	@echo "Checking output of $* stemmer for Go"
+	@cd go && if test -f '$</voc.txt.gz' ; then \
 	  gzip -dc '$</voc.txt.gz' > tmp.in; \
-	  $(NODE) javascript/stemwords.js -l `echo $<|sed 's!.*/!!'` -i tmp.in -o tmp.txt; \
+	  $(go) run $(goflags) -l $* -i tmp.in -o $(PWD)/tmp.txt; \
 	  rm tmp.in; \
 	else \
-	  $(NODE) javascript/stemwords.js -l `echo $<|sed 's!.*/!!'` -i $</voc.txt -o tmp.txt; \
+	  $(go) run $(goflags) -l $* -i $</voc.txt -o $(PWD)/tmp.txt; \
 	fi
 	@if test -f '$</output.txt.gz' ; then \
 	  gzip -dc '$</output.txt.gz'|$(DIFF) -u - tmp.txt; \
@@ -678,19 +725,28 @@ check_js_%: $(STEMMING_DATA)/%
 	fi
 	@rm tmp.txt
 
-check_python: check_python_stemwords $(libstemmer_algorithms:%=check_python_%)
+###############################################################################
+# Python
+###############################################################################
+
+.PHONY: python check_python do_check_python
+
+python: check_python_stemwords
+
+check_python: python
+	$(MAKE) $(libstemmer_algorithms:%=check_python_%)
 
 check_python_%: $(STEMMING_DATA_ABS)/%
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer for Python"
+	@echo "Checking output of $* stemmer for Python (THIN_FACTOR=$(THIN_FACTOR))"
 	@cd python_check && if test -f '$</voc.txt.gz' ; then \
-	  gzip -dc '$</voc.txt.gz'|$(THIN_TEST_DATA) > tmp.in; \
-	  $(python) stemwords.py -c utf8 -l `echo $<|sed 's!.*/!!'` -i tmp.in -o $(PWD)/tmp.txt; \
+	  gzip -dc '$</voc.txt.gz' $(THIN_TEST_DATA) > tmp.in; \
+	  $(python) stemwords.py -c utf8 -l $* -i tmp.in -o $(PWD)/tmp.txt; \
 	  rm tmp.in; \
 	else \
-	  $(python) stemwords.py -c utf8 -l `echo $<|sed 's!.*/!!'` -i $</voc.txt -o $(PWD)/tmp.txt; \
+	  $(python) stemwords.py -c utf8 -l $* -i $</voc.txt -o $(PWD)/tmp.txt; \
 	fi
 	@if test -f '$</output.txt.gz' ; then \
-	  gzip -dc '$</output.txt.gz'|$(THIN_TEST_DATA)|$(DIFF) -u - tmp.txt; \
+	  gzip -dc '$</output.txt.gz' $(THIN_TEST_DATA)|$(DIFF) -u - tmp.txt; \
 	else \
 	  $(DIFF) -u $</output.txt tmp.txt; \
 	fi
@@ -703,25 +759,27 @@ check_python_stemwords: $(PYTHON_STEMWORDS_SOURCE) $(PYTHON_SOURCES)
 	cp -a $(PYTHON_SOURCES) python_check/snowballstemmer
 	cp -a $(PYTHON_STEMWORDS_SOURCE) python_check/
 
-update_version:
-	perl -pi -e 's/(SNOWBALL_VERSION.*?)\d+\.\d+\.\d+/$${1}$(SNOWBALL_VERSION)/' \
-		compiler/header.h \
-		csharp/Snowball/AssemblyInfo.cs \
-		python/setup.py
+###############################################################################
+# Ada
+###############################################################################
+
+.PHONY: ada check_ada do_check_ada
+
+ada: ada/bin/stemwords
 
-check_ada: ada/bin/stemwords
+check_ada: ada
 	$(MAKE) do_check_ada
 
 do_check_ada: $(libstemmer_algorithms:%=check_ada_%)
 
 check_ada_%: $(STEMMING_DATA_ABS)/%
-	@echo "Checking output of `echo $<|sed 's!.*/!!'` stemmer for Ada"
+	@echo "Checking output of $* stemmer for Ada"
 	@cd ada && if test -f '$</voc.txt.gz' ; then \
 	  gzip -dc '$</voc.txt.gz' > tmp.in; \
-	  ./bin/stemwords `echo $<|sed 's!.*/!!'` tmp.in $(PWD)/tmp.txt; \
+	  ./bin/stemwords $* tmp.in $(PWD)/tmp.txt; \
 	  rm tmp.in; \
 	else \
-	  ./bin/stemwords `echo $<|sed 's!.*/!!'` $</voc.txt $(PWD)/tmp.txt; \
+	  ./bin/stemwords $* $</voc.txt $(PWD)/tmp.txt; \
 	fi
 	@if test -f '$</output.txt.gz' ; then \
 	  gzip -dc '$</output.txt.gz'|$(DIFF) -u - tmp.txt; \