Remakefile.in

   1 OCAMLFINDPACKAGES = "ulex,unix,expat,camlp4.macro"
   2 OCAMLFINDSYNTAX = camlp4o
   3 OCAMLFINDPPOPTS = $(addprefix "-ppopt ", @CAMLP4FLAGS@ -I include)
   4 OCAMLFINDINCLUDES = $(addprefix "-I ", src)
   5 OCAMLFINDFLAGS = -syntax $(OCAMLFINDSYNTAX) -package $(OCAMLFINDPACKAGES)  \
   6         $(OCAMLFINDPPOPTS) $(OCAMLFINDINCLUDES)
   7 OCAMLFINDLINKFLAGS = -linkpkg
   8 PACKAGE = @PACKAGE_TARNAME@
   9 SRC = src
  10 BIN = src/@PACKAGE_TARNAME@.native@EXE@
  11 EXE = @EXE@
  12
  13 REMAKE = @REMAKE@
  14 OCAMLDEP = @OCAMLDEP@
  15 ODEPS = tools/odeps.sh $(OCAMLDEP)
  16 OCAMLC = @OCAMLC@
  17 OCAMLOPT = @OCAMLOPT@
  18 OCAMLFLAGS = @OCAMLFLAGS@
  19 OCAMLOPTFLAGS = @OCAMLOPTFLAGS@
  20 OCAMLCFLAGS = @OCAMLCFLAGS@
  21 OCAMLYACC = @OCAMLYACC@
  22
  23 all: $(BIN)
  24
  25 tools: tools/xml_diff.native$(EXE) tools/XPathEval.class tools/split_path.native$(EXE)
  26
  27 Remakefile: Remakefile.in config.status
  28         ./config.status Remakefile
  29
  30 configure config.status: configure.in
  31         autoconf
  32         ./config.status --recheck
  33
  34 clean:
  35         for dir in src tools; do
  36                 find $dir -name '*.cm*' -o -name '*.o' -o -name '*.byte' -o \
  37                           -name '*.native' -o -name '*.mll' -o -name '*.mly' -o \
  38                           -name '*.class' -o -name '*.dep' | while read file; do
  39                 case "$file" in
  40                         *.mll)
  41                                 rm -f "${file%.mll}.ml"
  42                         ;;
  43                         *.mly)
  44                                 rm -f "${file%.mly}.ml" "${file%.mly}.mli"
  45                         ;;
  46                         *)
  47                         rm -f "$file"
  48                         ;;
  49                 esac
  50                 done
  51         done
  52
  53 distclean: clean test_clean
  54         rm -rf config.status configure config.log autom4te.cache .remake Remakefile remake
  55
  56 %.class: %.java
  57         javac $<
  58
  59 %.native$(EXE): %.cmx %.dep
  60         objects=`cat $*.dep | xargs | sed 's/[.]dep/.cmx/g'`
  61         $(OCAMLOPT) -o $@  $(OCAMLFLAGS) $(OCAMLOPTFLAGS) $(OCAMLFINDLINKFLAGS) $(OCAMLFINDFLAGS) $objects $<
  62
  63 %.byte$(EXE): %.cmo %.dep
  64         objects=`cat $*.dep | xargs | sed 's/[.]dep/.cmo/g'`
  65         $(OCAMLC) -o $@  $(OCAMLFLAGS) $(OCAMLCFLAGS) $(OCAMLFINDLINKFLAGS) $(OCAMLFINDFLAGS) $objects $<
  66
  67 %.ml:
  68         if test -f $*.mly; then
  69                 $(OCAMLYACC) $*.mly
  70         elif test -f $*.mll; then
  71                 $(OCAMLLEX) $*.mll
  72         fi
  73
  74 %.cmx %.dep:
  75         REMAKE="$(REMAKE) -v OCAMLNATIVE=-native"
  76         base=$*
  77         dirname=${base%/*}
  78         if test -f "$dirname".pack; then
  79                 #we are below a pack directory
  80                 PACKDIR=`basename $dirname`
  81                 PACKINCLUDE="-I $dirname"
  82         elif test -f $*.pack -a -d $*; then
  83                 $(REMAKE) $*.pack
  84                 PACKINCLUDE="-I $*"
  85                 PACKDIR=`basename $*`
  86                 DOPACK=1
  87         fi
  88         if test "$PACKDIR"; then
  89                 PACKNAME=`echo $PACKDIR | cut -b1 | tr a-z A-Z`${PACKDIR#?}
  90                 FORPACK="-for-pack $PACKNAME"
  91         fi
  92
  93         if test "$DOPACK"; then
  94                 modules=`cat $*.pack`
  95                 objects=`echo $modules | xargs tools/ocamlmoduledep.sh -native $PACKINCLUDE -I $(SRC) `
  96         else
  97                 $REMAKE $*.ml
  98                 modules=`$(OCAMLDEP) $(OCAMLFINDFLAGS) -modules $*.ml | cut -f 2- -d ':'`
  99                 objects=`tools/ocamlmoduledep.sh -native $PACKINCLUDE -I $(SRC) $modules`
 100         fi
 101
 102         $REMAKE $objects
 103
 104         deps=`echo $objects | sed 's/[.]cm[ix]/.dep/g'`
 105         rm -f $*.dep; touch $*.dep
 106         $(REMAKE) $deps
 107         for f in $deps; do
 108           for g in `cat $f`; do
 109               if grep -q $g $*.dep; then continue; fi
 110               echo $g >> $*.dep
 111            done
 112            if grep -q $f $*.dep; then continue; fi
 113            echo $f >> $*.dep
 114         done
 115         if test -f $*.mli; then $REMAKE -v PACKINCLUDE="$PACKINCLUDE" $*.cmi; fi
 116         if test "$DOPACK"; then
 117                 sorted_objects=`cat $*.dep | grep "$PACKDIR" | sed 's/[.]dep/.cmx/' | xargs`
 118                 cat $*.dep | grep -v "$PACKDIR" > $*.tmp
 119                 mv $*.tmp $*.dep
 120                 $(OCAMLOPT) -o $@ -pack $(OCAMLFLAGS) $(OCAMLOPTFLAGS) $(OCAMLFINDFLAGS) $sorted_objects
 121         else
 122                 $(OCAMLOPT) -o $@ $FORPACK -c $PACKINCLUDE $(OCAMLFLAGS) $(OCAMLOPTFLAGS) $(OCAMLFINDFLAGS) $*.ml
 123         fi
 124
 125 %.cmo %.dep:
 126         REMAKE="$(REMAKE)"
 127         base=$*
 128         dirname=${base%/*}
 129         if test -f "$dirname".pack; then
 130                 #we are below a pack directory
 131                 PACKDIR=`basename $dirname`
 132                 PACKINCLUDE="-I $dirname"
 133         elif test -f $*.pack -a -d $*; then
 134                 PACKINCLUDE="-I $*"
 135                 PACKDIR=`basename $*`
 136                 DOPACK=1
 137         fi
 138
 139         if test "$DOPACK"; then
 140                 modules=`cat $*.pack`
 141                 objects=`echo $modules | xargs tools/ocamlmoduledep.sh $PACKINCLUDE -I $(SRC) `
 142                 $REMAKE $objects
 143         else
 144                 $REMAKE $*.ml
 145                 modules=`$(OCAMLDEP) $(OCAMLFINDFLAGS) -modules $*.ml | cut -f 2- -d ':'`
 146                 objects=`tools/ocamlmoduledep.sh $PACKINCLUDE -I $(SRC) $modules`
 147                 $REMAKE $objects
 148         fi
 149
 150         deps=`echo $objects | sed 's/[.]cm[io]/.dep/g'`
 151         rm -f $*.dep; touch $*.dep
 152         $(REMAKE) $deps
 153         for f in $deps; do
 154            for g in `cat $f`; do
 155               if grep -q $g $*.dep; then continue; fi
 156               echo $g >> $*.dep
 157            done
 158            if grep -q $f $*.dep; then continue; fi
 159            echo $f >> $*.dep
 160         done
 161
 162         if test -f $*.mli; then $REMAKE -v PACKINCLUDE="$PACKINCLUDE" $*.cmi; fi
 163         if test "$DOPACK"; then
 164                 sorted_objects=`cat $*.dep | grep "$PACKDIR" | sed 's/[.]dep/.cmo/' | xargs`
 165                 cat $*.dep | grep -v "$PACKDIR" > $*.tmp
 166                 mv $*.tmp $*.dep
 167                 $(OCAMLC) -o $@ -pack $(OCAMLFLAGS) $(OCAMLCFLAGS) $(OCAMLFINDFLAGS) $sorted_objects
 168         else
 169                 $(OCAMLC) -o $@ -c $PACKINCLUDE $(OCAMLFLAGS) $(OCAMLCFLAGS) $(OCAMLFINDFLAGS)  $*.ml
 170         fi
 171
 172 %.cmi:
 173         $(REMAKE) $*.mli
 174         if test -z "$(OCAMLNATIVE)"; then
 175                 $(OCAMLC) -c $(OCAMLFLAGS) $(OCAMLCFLAGS) $(OCAMLFINDFLAGS) $(PACKINCLUDE) $*.mli
 176         else
 177                 $(OCAMLOPT) -c $(OCAMLFLAGS) $(OCAMLOPTFLAGS) $(OCAMLFINDFLAGS) $(PACKINCLUDE) $*.mli
 178
 179         fi
 180
 181 ## Tests
 182
 183 test: tools $(BIN)
 184         for i in tests/*.xml
 185         do
 186           for j in 1 2 3
 187           do
 188                 $(REMAKE) "$i".test"$j".summary
 189           done
 190         done
 191
 192 test_clean:
 193         rm -rf tests/*.summary tests/*.results/*_"$(PACKAGE)"_*.*
 194
 195 %.test1.summary:
 196                 base="$@"
 197                 base=${base%.xml.test1.summary}
 198                 $(REMAKE) "$base".xml "$base".xml.queries
 199                 rm -f "$@"
 200                 MSG="Test 1 (single query: tatoo vs java implementation)"
 201                 echo "$MSG" >> "$@"
 202                 echo "$MSG"
 203                 cat "$base".xml.queries | grep -v '^#' | while read q query; do
 204                         echo -n "$base"".xml $q $query ... "
 205                         REF="$base".xml.results/"$q"_jaxp.xml
 206                         $(REMAKE) "$REF"
 207                         OUTPUT="$base".xml.results/"$q"_"$(PACKAGE)"_test1.xml
 208                         LOG="$base".xml.results/"$q"_"$(PACKAGE)"_test1.log
 209                         cp "$@" /tmp
 210                         src/@PACKAGE_TARNAME@.native@EXE@ -s -d "$base".xml \
 211                                 "$query" -o "$OUTPUT" > "$LOG" 2>&1
 212                         cp "$@" /tmp
 213                         echo "Query: $q : $query" >> "$@"
 214                         cat  "$LOG" | grep '^STATS' >> "$@"
 215                         echo -n "Diff: " >> "$@"
 216                         if tools/xml_diff.native "$REF" "$OUTPUT" >/dev/null 2>&1; then
 217                                 echo ok
 218                                 echo ok >> "$@"
 219                         else
 220                                 echo failed
 221                                 echo failed >> "$@"
 222                                 exit 1
 223                         fi
 224                         echo '-------------------------------------------' >> "$@"
 225                 done
 226
 227 %.test2.summary:
 228                 base="$@"
 229                 base=${base%.xml.test2.summary}
 230                 $(REMAKE) "$base".xml "$base".xml.queries
 231                 rm -f "$@"
 232                 MSG="Test 2 (all queries sequentially vs all queries in parallel)"
 233                 echo "$MSG" >> "$@"
 234                 echo "$MSG"
 235                 allqueries=`cat "$base".xml.queries | grep -v '^#' | while read q query; do echo "'$query'"; done`
 236                 echo -n "Running all queries ... "
 237                 OUTPUTA="$base".xml.results/test2a_"$(PACKAGE)".xml
 238                 LOG="$base".xml.results/test2a_"$(PACKAGE)".log
 239                 echo -n "sequential ... "
 240                 echo "$allqueries" | xargs src/@PACKAGE_TARNAME@.native@EXE@ -s -d "$base".xml \
 241                  -o "$OUTPUTA" > "$LOG" 2>&1
 242                 cat  "$LOG" | grep '^STATS' >> "$@"
 243
 244                 OUTPUTB="$base".xml.results/test2b_"$(PACKAGE)".xml
 245                 LOG="$base".xml.results/test2b_"$(PACKAGE)".log
 246                 echo -n "parallel ... "
 247                 echo "$allqueries" | xargs src/@PACKAGE_TARNAME@.native@EXE@ -p -s -d "$base".xml \
 248                  -o "$OUTPUTB" > "$LOG" 2>&1
 249                 cat  "$LOG" | grep '^STATS' >> "$@"
 250                         echo -n "Diff: " >> "$@"
 251                 if diff "$OUTPUTA" "$OUTPUTB" >/dev/null 2>&1; then
 252                         echo ok
 253                         echo ok >> "$@"
 254                 else
 255                         echo failed
 256                         echo failed >> "$@"
 257                         exit 1
 258                 fi
 259                 echo '-------------------------------------------' >> "$@"
 260
 261 %.test3.summary:
 262                 base="$@"
 263                 base=${base%.xml.test3.summary}
 264                 $(REMAKE) "$base".xml "$base".xml.queries
 265                 rm -f "$@"
 266                 MSG="Test 3 (multiple queries composition: sequential vs parallel)"
 267                 echo "$MSG" >> "$@"
 268                 echo "$MSG"
 269                 cat "$base".xml.queries | grep -v '^#' | while read q query; do
 270                         echo -n "$base"".xml $q $query ... sequential ... "
 271                         OUTPUTA="$base".xml.results/"$q"_"$(PACKAGE)"_test3a.xml
 272                         LOG="$base".xml.results/"$q"_"$(PACKAGE)"_test3a.log
 273                         src/@PACKAGE_TARNAME@.native@EXE@ -s -d -C "$base".xml \
 274                                  -o "$OUTPUTA" $(tools/split_path.native$(EXE) "$query") > "$LOG" 2>&1
 275                         echo "Query: $q : $query" >> "$@"
 276                         cat  "$LOG" | grep '^STATS' >> "$@"
 277
 278                         echo -n "parallel ... "
 279                         OUTPUTB="$base".xml.results/"$q"_"$(PACKAGE)"_test3a.xml
 280                         LOG="$base".xml.results/"$q"_"$(PACKAGE)"_test3a.log
 281                         src/@PACKAGE_TARNAME@.native@EXE@ -s -d -p -C "$base".xml \
 282                                  -o "$OUTPUTB" $(tools/split_path.native$(EXE) "$query") > "$LOG" 2>&1
 283                         echo "Query: $q : $query" >> "$@"
 284                         cat  "$LOG" | grep '^STATS' >> "$@"
 285
 286
 287                         echo -n "Diff: " >> "$@"
 288                         if diff  "$OUTPUTA" "$OUTPUTB" >/dev/null 2>&1; then
 289                                 echo ok
 290                                 echo ok >> "$@"
 291                         else
 292                                 echo failed
 293                                 echo failed >> "$@"
 294                                 exit 1
 295                         fi
 296                         echo '-------------------------------------------' >> "$@"
 297                 done