INPUT	= ./sample.txt
#INPUT	= ./sample_kurz.txt
#INPUT	= ./sample_mittel.txt
VERIFY	= /etc/passwd

# Ein Directory für Temporäres, kann jederzeit gelöscht werden
TMP	= ./tmp

MEASURE	= /usr/bin/time --format "result: %C | %e | %S | %U | %x | %P"
DIFF	= diff
RM	= rm -f
CPP	= g++
COMPRESS=cd ./output/; ls | grep -v .gz | xargs gzip -9

runall: 001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 \
        020 022 023 024 025 026 027 028 029 032 033 034 035 036 037 038 039 040 041 \
        042 043 044 045 046 047 048 052 053 054 055 057 058 059 060 061 062 063

dorun: allclean
	ulimit -t 120; make -k runall


allclean:
	$(RM) ./output/*
	$(RM) ./error/*

stat:
	cat error/* | grep "^result" | sed 's/^.*\.\/0/0/;s/\.[^\|]*//' | sort -n -k2 -r

# Programm 001 -- angepasst von: Peter

001:
	$(MEASURE) python ./001.py -a < $(INPUT) > ./output/001.txt 2> ./error/001.txt
	$(COMPRESS)

001-verify:
	$(DIFF) ./output/001.txt $(VERIFY)

001-clean:
	$(RM) ./output/001.txt


# Programm 002 -- Perl -- angepasst von: Nils

002:
	$(MEASURE) ./002.pl < $(INPUT) > ./output/002.txt 2> ./error/002.txt
	$(COMPRESS)

002-verify:
	$(DIFF) ./output/002.txt $(VERIFY)

002-clean:
	$(RM) ./output/002.txt


# Programm 003 -- Perl -- angepasst von: Nils

003:
	$(MEASURE) ./003.pl < $(INPUT) > ./output/003.txt 2> ./error/003.txt
	$(COMPRESS)

003-verify:
	$(DIFF) ./output/003.txt $(VERIFY)

003-clean:
	$(RM) ./output/003.txt


# Programm 004 -- Ruby angepasst von: Nils

004:
	$(MEASURE) ./004.rb $(INPUT) > ./output/004.txt 2> ./error/004.txt
	$(COMPRESS)

004-verify:
	$(DIFF) ./output/004.txt $(VERIFY)

004-clean:
	$(RM) ./output/004.txt


# Programm 005 -- Groovy angepasst von: Nils

005:
	$(MEASURE) groovy ./o005.groovy $(INPUT) > ./output/005.txt 2> ./error/005.txt
	$(COMPRESS)

005-verify:
	$(DIFF) ./output/005.txt $(VERIFY)

005-clean:
	$(RM) ./output/005.txt



# Programm 006 -- Tcl -- angepasst von: Nils und Achim

006:
	$(MEASURE) ./006.tcl $(INPUT) > ./output/006.txt 2> ./error/006.txt
	$(COMPRESS)

006-verify:
	$(DIFF) ./output/006.txt $(VERIFY)

006-clean:
	$(RM) ./output/006.txt


# Programm 007 -- Perl -- angepasst von: Nils

007:
	$(MEASURE) ./007.pl -f $(INPUT) > ./output/007.txt 2> ./error/007.txt
	$(COMPRESS)

007-verify:
	$(DIFF) ./output/007.txt $(VERIFY)

007-clean:
	$(RM) ./output/007.txt


# Programm 009 -- Ruby -- angepasst von: Nils

009:
	$(MEASURE) ruby ./009.rb < $(INPUT) > ./output/009.txt 2> ./error/009.txt
	$(COMPRESS)

009-verify:
	$(DIFF) ./output/009.txt $(VERIFY)

009-clean:
	$(RM) ./output/009.txt


# Programm 010 -- Python -- angepasst von: Nils

010:
	$(MEASURE) ./010.py < $(INPUT) > ./output/010.txt 2> ./error/010.txt

010-verify:
	$(DIFF) ./output/010.txt $(VERIFY)

010-clean:
	$(RM) ./output/010.txt


# Programm 011 -- Python -- angepasst von: Nils

011:
	$(MEASURE) ./011.py $(INPUT) > ./output/011.txt 2> ./error/011.txt

011-verify:
	$(DIFF) ./output/011.txt $(VERIFY)

011-clean:
	$(RM) ./output/011.txt


# Programm 012 -- Python -- angepasst von: Nils

012:
	$(MEASURE) ./012.py < $(INPUT) > ./output/012.txt 2> ./error/012.txt
	$(COMPRESS)

012-verify:
	$(DIFF) ./output/012.txt $(VERIFY)

012-clean:
	$(RM) ./output/012.txt


# Programm 013 -- angepasst von: Nils

013:
	$(MEASURE) ./013.py < $(INPUT) > ./output/013.txt 2> ./error/013.txt

013-verify:
	$(DIFF) ./output/013.txt $(VERIFY)

013-clean:
	$(RM) ./output/013.txt


# Programm 014 -- angepasst von: Nils

014:
	$(MEASURE) ./014.pl $(INPUT) > ./output/014.txt 2> ./error/014.txt

014-verify:
	$(DIFF) ./output/014.txt $(VERIFY)

014-clean:
	$(RM) ./output/014.txt


# Programm 015 -- Java angepasst von: Nils

015:
	cp ./015.java ./tmp/FootnoteProcessor.java
	cd ./tmp; javac FootnoteProcessor.java
	cd ./tmp; $(MEASURE) java FootnoteProcessor $(INPUT) > ../output/015.txt 2> ../error/015.txt
	$(COMPRESS)

015-verify:
	$(DIFF) ./output/015.txt $(VERIFY)

015-clean:
	$(RM) ./output/015.txt


# Programm 016 -- angepasst von Peter

016:
	$(MEASURE) python ./016.py $(INPUT) > ./output/016.txt 2> ./error/016.txt

016-verify:
	$(DIFF) ./output/016.txt $(VERIFY)

016-clean:
	$(RM) ./output/016.txt


# Programm 017 -- noch nicht angepasst (bitte entfernen) angepasst von:

017:
	$(MEASURE) ./017.tcl -t $(INPUT) > ./output/017.txt 2> ./error/017.txt

017-verify:
	$(DIFF) ./output/017.txt $(VERIFY)

017-clean:
	$(RM) ./output/017.txt


# Programm 018 -- noch nicht angepasst (bitte entfernen) angepasst von:

018:
	cd ./tmp; unzip -o -q ../018.java-eclipse.zip 
	cd ./tmp/BibOrder/dist; $(MEASURE) java -jar BibOrder.jar $(INPUT) > ../../../output/018.txt 2> ../../../error/018.txt 

018-verify:
	$(DIFF) ./output/018.txt $(VERIFY)

018-clean:
	$(RM) ./output/018.txt


# Programm 020 -- Java angepasst von: Nils

020:
	cp ./020.java ./tmp/textnumbers.java
	cd ./tmp; javac textnumbers.java
	cd ./tmp; $(MEASURE) java textnumbers $(INPUT) > ../output/020-stdout.txt 2> ../error/020.txt && mv *.neu.txt ./output/020.txt
	$(COMPRESS)

020-verify:
	$(DIFF) ./output/020.txt $(VERIFY)

020-clean:
	$(RM) ./output/020.txt


# Programm 021 -- noch nicht angepasst (bitte entfernen) angepasst von: Nils
# geht aber noch nicht, weil das Tool fest "footnotes.txt" einliest.
# das Programm enthält außer der fehlenden Angabe der Codierung auch noch einen Syntaxfehler in Zeile 44, Peter gedenkt es aus der Wertung rauszuschmeißen!

021:
	$(MEASURE) python ./021.py < $(INPUT) > ./output/021.txt 2> ./error/021.txt

021-verify:
	$(DIFF) ./output/021.txt $(VERIFY)

021-clean:
	$(RM) ./output/021.txt


# Programm 022 -- angepasst von: Nils

022:
	$(MEASURE) ./022.py < $(INPUT) > ./output/022.txt 2> ./error/022.txt

022-verify:
	$(DIFF) ./output/022.txt $(VERIFY)

022-clean:
	$(RM) ./output/022.txt


# Programm 023 -- angepasst von: Nils

023:
	$(MEASURE) ./023.awk < $(INPUT) > ./output/023.txt 2> ./error/023.txt

023-verify:
	$(DIFF) ./output/023.txt $(VERIFY)

023-clean:
	$(RM) ./output/023.txt


# Programm 024 -- noch nicht angepasst (bitte entfernen) angepasst von:

024:
	$(MEASURE) ./024.rb $(INPUT) > ./output/024.txt 2> ./error/024.txt
	$(COMPRESS)

024-verify:
	$(DIFF) ./output/024.txt $(VERIFY)

024-clean:
	$(RM) ./output/024.txt


# Programm 025 -- angepasst von: Peter

025:
	$(MEASURE) python ./025.py  $(INPUT) > ./output/025.txt 2> ./error/025.txt

025-verify:
	$(DIFF) ./output/025.txt $(VERIFY)

025-clean:
	$(RM) ./output/025.txt



# Programm 026 -- angepasst von: Nils

026:
	$(MEASURE) ./026.rb $(INPUT) > ./output/026.txt 2> ./error/026.txt

026-verify:
	$(DIFF) ./output/026.txt $(VERIFY)

026-clean:
	$(RM) ./output/026.txt


# Programm 027 -- angepasst von: Peter

027:
	$(MEASURE) ./027.awk < $(INPUT) > ./output/027.txt 2> ./error/027.txt
	$(COMPRESS)

027-verify:
	$(DIFF) ./output/027.txt $(VERIFY)

027-clean:
	$(RM) ./output/027.txt


# Programm 028 -- angepasst von: Peter

028:
	$(MEASURE) ./028.sh < $(INPUT) > ./output/028.txt 2> ./error/028.txt

028-verify:
	$(DIFF) ./output/028.txt $(VERIFY)

028-clean:
	$(RM) ./output/028.txt


# Programm 029 -- noch nicht angepasst (bitte entfernen) angepasst von:

029:
	$(MEASURE) ./029.tcl $(INPUT) > ./output/029.txt 2> ./error/029.txt

029-verify:
	$(DIFF) ./output/029.txt $(VERIFY)

029-clean:
	$(RM) ./output/029.txt


# Programm 031 -- bricht bei mir mit 3 Compilation-Errors ab: Peter

031:
	$(MEASURE) ./031.pl < $(INPUT) > ./output/031.txt 2> ./error/031.txt

031-verify:
	$(DIFF) ./output/031.txt $(VERIFY)

031-clean:
	$(RM) ./output/031.txt


# Programm 032 -- angepasst von: Peter

032:
	$(MEASURE) python ./032.py $(INPUT) > ./output/032.txt 2> ./error/032.txt
	$(COMPRESS)

032-verify:
	$(DIFF) ./output/032.txt $(VERIFY)

032-clean:
	$(RM) ./output/032.txt


# Programm 033 -- angepasst von: Nils

033:
	$(MEASURE) ./033.pl $(INPUT) > ./output/033.txt 2> ./error/033.txt

033-verify:
	$(DIFF) ./output/033.txt $(VERIFY)

033-clean:
	$(RM) ./output/033.txt


# Programm 034 -- noch nicht angepasst (bitte entfernen) angepasst von:

034:
	$(MEASURE) ./034.pl < $(INPUT) > ./output/034.txt 2> ./error/034.txt

034-verify:
	$(DIFF) ./output/034.txt $(VERIFY)

034-clean:
	$(RM) ./output/034.txt


# Programm 035 -- angepasst von: Peter

035:
	$(MEASURE) ./035.pl $(INPUT) > ./output/035.txt 2> ./error/035.txt
	$(COMPRESS)

035-verify:
	$(DIFF) ./output/035.txt $(VERIFY)

035-clean:
	$(RM) ./output/035.txt


# Programm 036 -- angepasst von: Peter

036:
	$(MEASURE) ./036.x86 < $(INPUT) > ./output/036.txt 2> ./error/036.txt

036-verify:
	$(DIFF) ./output/036.txt $(VERIFY)

036-clean:
	$(RM) ./output/036.txt


# Programm 037 -- angepasst von: Nils

037:
	ghc -o 037.bin -Wall -O2 --make 037.hs
	$(MEASURE) ./037.bin $(INPUT) > ./output/037.txt 2> ./error/037.txt

037-verify:
	$(DIFF) ./output/037.txt $(VERIFY)

037-clean:
	$(RM) ./output/037.txt



# Programm 039 -- angepasst von: Peter

039:
	$(MEASURE) ./039.awk < $(INPUT) > ./output/039.txt 2> ./error/039.txt
	$(COMPRESS)

039-verify:
	$(DIFF) ./output/039.txt $(VERIFY)

039-clean:
	$(RM) ./output/039.txt


# Programm 040 -- noch nicht angepasst (bitte entfernen) angepasst von:

040:
	$(MEASURE) ./040.py $(INPUT) > ./output/040.txt 2> ./error/040.txt

040-verify:
	$(DIFF) ./output/040.txt $(VERIFY)

040-clean:
	$(RM) ./output/040.txt


# Programm 041 -- angepasst von: Peter

041:
	$(MEASURE) ./041.pl < $(INPUT) > ./output/041.txt 2> ./error/041.txt

041-verify:
	$(DIFF) ./output/041.txt $(VERIFY)

041-clean:
	$(RM) ./output/041.txt


# Programm 042 -- angepasst von: Peter und Nils

042:
	cp ./042.main.cs ./042.class.cs ./tmp
	cd ./tmp; gmcs ./042.main.cs ./042.class.cs; mv 042.main.exe ..
	$(MEASURE) mono ./042.main.exe $(INPUT) > ./output/042.txt 2> ./error/042.txt

042-verify:
	$(DIFF) ./output/042.txt $(VERIFY)

042-clean:
	$(RM) ./output/042.txt



# Programm 045 -- angepasst von: Peter

045:
	$(MEASURE) ./045.py < $(INPUT) > ./output/045.txt 2> ./error/045.txt

045-verify:
	$(DIFF) ./output/045.txt $(VERIFY)

045-clean:
	$(RM) ./output/045.txt


# Programm 046 -- angepasst von: Peter

046:
	$(MEASURE) ./046.py $(INPUT) > ./output/046.txt 2> ./error/046.txt
	$(COMPRESS)

046-verify:
	$(DIFF) ./output/046.txt $(VERIFY)

046-clean:
	$(RM) ./output/046.txt


# Programm 047 -- angepasst von: Peter

047:
	$(MEASURE) ./047.py  $(INPUT) > ./output/047.txt 2> ./error/047.txt

047-verify:
	$(DIFF) ./output/047.txt $(VERIFY)

047-clean:
	$(RM) ./output/047.txt


# Programm 051 -- Java angepasst von: Nils
# compiled nicht ...

051:
	cp ./051.java ./tmp/Indexer.java
	cd ./tmp; javac Indexer.java
	cd ./tmp; $(MEASURE) java Indexer ../$(INPUT) > ../output/051.txt 2> ../error/051.txt

051-verify:
	$(DIFF) ./output/051.txt $(VERIFY)

051-clean:
	$(RM) ./output/051.txt


# Programm 054 -- angepasst von: Peter

054:
	$(MEASURE) ./054.pl  $(INPUT)  ./output/054.txt ./output/054b.txt 2> ./error/054.txt

054-verify:
	$(DIFF) ./output/054.txt $(VERIFY)

054-clean:
	$(RM) ./output/054.txt


# Programm 055 -- angepasst von: Peter

055:
	$(MEASURE) python ./055.py  $(INPUT) > ./output/055.txt 2> ./error/055.txt
	$(COMPRESS)

055-verify:
	$(DIFF) ./output/055.txt $(VERIFY)

055-clean:
	$(RM) ./output/055.txt


# Programm 057 -- noch nicht angepasst (bitte entfernen) angepasst von:

057:
	$(MEASURE) ruby ./057.rb < $(INPUT) > ./output/057.txt 2> ./error/057.txt

057-verify:
	$(DIFF) ./output/057.txt $(VERIFY)

057-clean:
	$(RM) ./output/057.txt


# Programm 058 -- angepasst von: Nils

058:
	$(MEASURE) ./058.rb $(INPUT) > ./output/058.txt 2> ./error/058.txt

058-verify:
	$(DIFF) ./output/058.txt $(VERIFY)

058-clean:
	$(RM) ./output/058.txt


# Programm 059 -- angepasst von: Peter

059:
	$(MEASURE) ./059.pl $(INPUT) > ./output/059.txt 2> ./error/059.txt
	$(COMPRESS)

059-verify:
	$(DIFF) ./output/059.txt $(VERIFY)

059-clean:
	$(RM) ./output/059.txt


# Programm 060 -- angepasst von: Peter

060:
	$(MEASURE) ./060.pl $(INPUT) > ./output/060.txt 2> ./error/060.txt

060-verify:
	$(DIFF) ./output/060.txt $(VERIFY)

060-clean:
	$(RM) ./output/060.txt


# Programm 061 -- ngepasst von: Peter

061:
	$(MEASURE) ./061.pl $(INPUT) > ./output/061.txt 2> ./error/061.txt
	$(COMPRESS)

061-verify:
	$(DIFF) ./output/061.txt $(VERIFY)

061-clean:
	$(RM) ./output/061.txt


# Programm 062 -- angepasst von: Peter

062:
	$(MEASURE) ./062.pl $(INPUT) > ./output/062.txt 2> ./error/062.txt

062-verify:
	$(DIFF) ./output/062.txt $(VERIFY)

062-clean:
	$(RM) ./output/062.txt


# Programm 063 -- angepasst von: Nils

063:
	$(MEASURE) ./063.rb $(INPUT) > ./output/063.txt 2> ./error/063.txt
	$(COMPRESS)

063-verify:
	$(DIFF) ./output/063.txt $(VERIFY)

063-clean:
	$(RM) ./output/063.txt


# ------------------------------------------


# groovy:
005: 


# Programm 008 -- angepasst von: Nils
008:
	$(CPP) -o 008.bin 008.cpp
	$(MEASURE) ./008.bin $(INPUT) > ./output/008.txt 2> ./error/008.txt
	$(COMPRESS)

008-verify:
	$(DIFF) ./output/008.txt $(VERIFY)

008-clean:
	$(RM) ./output/008.txt


# Programm 019 -- angepasst von: Nils
019:
	$(CPP) -O2 -lpcrecpp 019.cpp -o 019.bin
	$(MEASURE) ./019.bin $(INPUT) > ./output/019.txt 2> ./error/019.txt

019-verify:
	$(DIFF) ./output/019.txt $(VERIFY)

019-clean:
	$(RM) ./output/019.txt


# Programm 030 -- angepasst von: Nils
# Offenbar braucht man dazu boost-1.35
030:
	$(CPP) -lboost_filesystem -lboost_program_options -o 030.bin 030.cpp
	$(MEASURE) ./030.bin $(INPUT) > ./output/030.txt 2> ./error/030.txt
	$(COMPRESS)

030-verify:
	$(DIFF) ./output/030.txt $(VERIFY)

030-clean:
	$(RM) ./output/030.txt


# Programm 038 -- angepasst von: Nils
038:
	$(CPP) -o 038.bin 038.cpp -lboost_regex
	$(MEASURE) ./038.bin $(INPUT) > ./output/038.txt 2> ./error/038.txt

038-verify:
	$(DIFF) ./output/038.txt $(VERIFY)

038-clean:
	$(RM) ./output/038.txt


# Programm 043 -- angepasst von: Nils
043:
	flex -o 043.cpp 043.f
	$(CPP) -o 043.bin 043.cpp -lstdc++ -lfl
	$(MEASURE) ./043.bin $(INPUT) > ./output/043.txt 2> ./error/043.txt
	$(COMPRESS)

043-verify:
	$(DIFF) ./output/043.txt $(VERIFY)

043-clean:
	$(RM) ./output/043.txt


# Programm 044 -- angepasst von: Nils
044:
	flex 044.ll && mv ./footnotes.cpp 044.cpp
	$(CPP) -O2 -pipe -o 044.bin 044.cpp
	$(MEASURE) ./044.bin < $(INPUT) > ./output/044.txt 2> ./error/044.txt
	$(COMPRESS)

044-verify:
	$(DIFF) ./output/044.txt $(VERIFY)

044-clean:
	$(RM) ./output/044.txt


# Programm 048 -- angepasst von: Nils
048:
	$(CPP) -o 048.bin 048.cpp
	$(MEASURE) ./048.bin $(INPUT) > ./output/048.txt 2> ./error/048.txt

048-verify:
	$(DIFF) ./output/048.txt $(VERIFY)

048-clean:
	$(RM) ./output/048.txt


# Programm 050 -- angepasst von: Nils
050:
	ocamlopt -o ./050.bin str.cmxa 050.ml
	$(MEASURE) ./050.bin $(INPUT) > ./output/050.txt 2> ./error/050.txt
	$(COMPRESS)

050-verify:
	$(DIFF) ./output/050.txt $(VERIFY)

050-clean:
	$(RM) ./output/050.txt


# Programm 052 -- angepasst von: Nils
052:
	$(CPP) -Wall -O2 -o 052.bin 052.cpp -lboost_regex-mt
	$(MEASURE) ./052.bin $(INPUT) > ./output/052.txt 2> ./error/052.txt

052-verify:
	$(DIFF) ./output/052.txt $(VERIFY)

052-clean:
	$(RM) ./output/052.txt


# Programm 053 -- angepasst von: Nils
053:
	$(CPP) -o 053.bin 053.cpp
	$(MEASURE) ./053.bin -f $(INPUT) > ./output/053.txt 2> ./error/053.txt
	$(COMPRESS)

053-verify:
	$(DIFF) ./output/053.txt $(VERIFY)

053-clean:
	$(RM) ./output/053.txt