ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/build.xml

Comparing jsr166/build.xml (file contents):
Revision 1.28 by tim, Wed May 28 13:37:59 2003 UTC vs.
Revision 1.39 by tim, Sat May 31 17:24:03 2003 UTC

#	Line 1 | Line 1
1		<project name="jsr166" default="usage">
2
3		<description>
4	<	Build file for JSR-166
4	>	------------------------------------------------------------------------------
5	>	Build file for JSR-166
6
7	<	JUnit 3.8 or better must be in ${ant.home}/lib for the test target to work.
7	<	</description>
7	>	Usage: ant [target]
8
9	+	User-specific settings are read from user.properties.
10	+	See user.properties.sample for an explanation of some useful settings.
11	+	------------------------------------------------------------------------------
12	+	</description>
13
14	<	<target name="usage" description="Prints this message">
15	<	<echo>
12	<	ant [target], where target is one of:
13	<
14	<	usage       (default) Prints this message
15	<	compile     Compiles all sources to build folder
16	<	jar         Builds library jar from compiled sources
17	<	test        Runs all tests (requires JUnit 1.8 in ${ant.home}/lib)
18	<	docs        Builds javadocs with custom tags to build folder
19	<	dist-docs   Builds javadocs without custom tags to dist folder
20	<	dist        Puts all distributable products in single hierarchy
21	<
22	<	clean       Removes all build products
23	<	dist-clean  Removes all build and distribution products
24	<
25	<	checkstyle  Reports on style errors in Java source (verbose, mostly chaff)
26	<	doccheck    Reports on javadoc style errors (not working yet)
27	<	</echo>
14	>	<target name="usage" description="Advises user to run with -projecthelp">
15	>	<echo>Run "ant -projecthelp" for full usage information.</echo>
16		</target>
17
18	+
19		<!-- User-specific settings -->
20		<property file="user.properties"/>
21
33	–	<!-- Set build.warnings in user.properties to turn on -warnunchecked -->
34	–	<!-- <property name="build.warnings" value=""/> -->
35	–
22
23		<!-- Compilation options -->
24		<property name="build.sourcelevel"    value="1.5"/>
#	Line 68 | Line 54 | ant [target], where target is one of:
54
55		<!-- Jar locations -->
56		<property name="product.jar"          location="${build.lib.dir}/jsr166.jar"/>
71	–	<property name="javac.jar"            location="${lib.dir}/javac.jar"/>
72	–	<property name="collect.jar"          location="${lib.dir}/collect.jar"/>
57		<property name="junit.jar"            location="${lib.dir}/junit.jar"/>
58		<property name="rt.jar"               location="${java.home}/lib/rt.jar"/>
59
60
61
78	–	<!--
79	–	! Bootclasspath munging for source compilation.
80	–	-->
81	–
82	–	<path id="javac.bootclasspath.prefix">
83	–	<!-- <pathelement location="${src.dir}"/> -->
84	–	<pathelement location="${javac.jar}"/>
85	–	</path>
86	–
87	–	<path id="javac.bootclasspath">
88	–	<!-- <pathelement location="${src.dir}"/> -->
89	–	<pathelement location="${collect.jar}"/>
90	–	<pathelement location="${rt.jar}"/>
91	–	</path>
92	–
93	–	<!-- Flatten bootclasspath prefix into a platform-appropriate string -->
94	–	<property name="javac.bootclasspath.prefix" refid="javac.bootclasspath.prefix"/>
95	–
96	–	<!-- Turn the flattened bootclasspath prefix into a javac argument -->
97	–	<property name="javac.args" value='-J-Xbootclasspath/p:${javac.bootclasspath.prefix}'/>
98	–
99	–
100	–
101	–	<!--
102	–	! Bootclasspath munging for testing, so JUnit can test our local
103	–	! modifications to java.*.
104	–	-->
105	–
106	–	<path id="test.classpath">
107	–	<pathelement location="${product.jar}"/>
108	–	<pathelement location="${build.testcases.dir}"/>
109	–	<pathelement location="${junit.jar}"/>
110	–	</path>
111	–
112	–	<!-- Flatten test classpath into a platform-appropriate string -->
113	–	<property name="test.classpath" refid="test.classpath"/>
114	–
115	–	<!-- Turn the flattened test classpath into a javac argument -->
116	–	<property name="test.javac.args" value='-Xbootclasspath/p:${test.classpath}'/>
117	–
118	–
119	–
62		<!-- Files excluded from emulation and dist-docs -->
63		<patternset id="emulation.excludes">
64		<exclude name="java/util/Random.*"/>
#	Line 128 | Line 70 | ant [target], where target is one of:
70		<!-- Main targets -->
71
72		<target name="compile"
73	<	depends="init"
73	>	depends="init, configure-compiler, prepare-src"
74		description="Compiles main sources to build folder">
75
76	+	<property name="prepare.src.dir" value="${src.dir}"/>
77	+
78		<mkdir dir="${build.classes.dir}"/>
79
80	<	<javac srcdir="${src.dir}"
80	>	<!--
81	>	<echo>javac ${gjc.args}</echo>
82	>	<echo>bootclasspath=${compile.bootclasspath}</echo>
83	>	-->
84	>
85	>	<javac srcdir="${prepare.src.dir}"
86		destdir="${build.classes.dir}"
87		debug="${build.debug}"
88		debuglevel="${build.debuglevel}"
#	Line 141 | Line 90 | ant [target], where target is one of:
90		source="${build.sourcelevel}"
91		fork="true">
92
93	<	<bootclasspath refid="javac.bootclasspath"/>
94	<	<compilerarg line="${javac.args} ${build.warnings.option}"/>
93	>	<compilerarg    line="${gjc.args}"/>
94	>	<bootclasspath refid="compile.bootclasspath"/>
95
96		</javac>
97
#	Line 150 | Line 99 | ant [target], where target is one of:
99
100
101		<target name="jar"
102	<	depends="native-jar, emulation-jar"
102	>	depends="configure-emulation, init-jar, native-jar, emulation-jar"
103		description="Builds library jar from compiled sources"/>
104
105
106		<target name="test"
107	<	depends="init, check-junit, report-tests"
108	<	description="Runs all tests (requires JUnit 3.8+ in ${ant.home}/lib)" />
107	>	depends="init, configure-tests, report-tests"
108	>	description="Runs all tests (requires JUnit 3.8.1 in ${ant.home}/lib)" />
109
110
111		<target name="checkstyle"
#	Line 203 | Line 152 | ant [target], where target is one of:
152		source="${build.docsourcelevel}">
153
154		<tag name="revised" description="Last revised:"/>
155	<	<tag name="spec" description="Specified by:"/>
156	<	<tag name="editor" description="Last edited by:"/>
157	<	<tag name="fixme" description="FIX ME:"/>
155	>	<tag name="spec"    description="Specified by:"/>
156	>	<tag name="editor"  description="Last edited by:"/>
157	>	<tag name="fixme"   description="FIX ME:"/>
158	>
159		<packageset dir="${build.filter.src.dir}"/>
160
161		</javadoc>
#	Line 213 | Line 163 | ant [target], where target is one of:
163		</target>
164
165
216	–	<!--
217	–	# javac -s doesn't reliably generate compilable code. It generates
218	–	# bridge methods (marked as "synthetic") that can have identical
219	–	# signatures to existing methods except for the return value.
220	–	-->
166		<target name="strip"
167	<	depends="init">
167	>	depends="init, configure-compiler"
168	>	description="Strip generics from java source (not working yet)">
169
170		<mkdir dir="${build.stripped.dir}"/>
171
172	+	<!--
173	+	# javac -s doesn't reliably generate compilable code. It generates
174	+	# bridge methods (marked as "synthetic") that can have identical
175	+	# signatures to existing methods except for the return value.
176	+	-->
177		<javac srcdir="${src.dir}"
178		destdir="${build.stripped.dir}"
179		debug="${build.debug}"
#	Line 231 | Line 182 | ant [target], where target is one of:
182		source="${build.sourcelevel}"
183		fork="true">
184
185	<	<bootclasspath refid="javac.bootclasspath"/>
186	<	<compilerarg line="${javac.args} ${build.warnings.option} -s"/>
185	>	<compilerarg    line="${gjc.args} -s"/>
186	>	<bootclasspath refid="compile.bootclasspath"/>
187
188		</javac>
189
#	Line 284 | Line 235 | ant [target], where target is one of:
235
236		<!-- Internal targets -->
237
287	–	<target name="set-warnings-if" if="build.warnings">
288	–
289	–	<property name="build.warnings.option" value="-warnunchecked"/>
290	–
291	–	</target>
292	–
293	–
294	–	<target name="set-warnings-unless" unless="build.warnings">
238
239	<	<property name="build.warnings.option" value=""/>
297	<
298	<	</target>
299	<
300	<
301	<	<target name="init"
302	<	depends="set-warnings-if, set-warnings-unless">
239	>	<target name="init">
240
241		<!-- Version is kept in a separate file -->
242		<loadfile property="version" srcFile="version.properties"/>
#	Line 316 | Line 253 | ant [target], where target is one of:
253
254
255		<target name="native-jar"
256	<	depends="compile, init-jar"
257	<	unless="build.emulation">
256	>	depends="compile"
257	>	unless="build.emulation.true">
258
259		<jar destfile="${product.jar}">
260		<fileset dir="${build.classes.dir}"/>
#	Line 326 | Line 263 | ant [target], where target is one of:
263		</target>
264
265
329	–	<target name="base-jar"
330	–	depends="compile, init-jar">
331	–
332	–	<jar destfile="${product.jar}">
333	–	<fileset dir="${build.classes.dir}">
334	–	<patternset refid="emulation.excludes"/>
335	–	</fileset>
336	–	</jar>
337	–
338	–	</target>
339	–
340	–
266		<target name="compile-emulation"
267	<	depends="init"
268	<	if="build.emulation">
267	>	depends="init, configure-compiler"
268	>	if="build.emulation.true">
269
270		<mkdir dir="${build.emulation.dir}"/>
271
#	Line 352 | Line 277 | ant [target], where target is one of:
277		source="${build.sourcelevel}"
278		fork="true">
279
280	<	<bootclasspath refid="javac.bootclasspath"/>
281	<	<compilerarg line="${javac.args} ${build.warnings.option}"/>
280	>	<compilerarg    line="${gjc.args}"/>
281	>	<bootclasspath refid="compile.bootclasspath"/>
282
283		</javac>
284
#	Line 361 | Line 286 | ant [target], where target is one of:
286
287
288		<target name="emulation-jar"
289	<	depends="base-jar, compile-emulation"
290	<	if="build.emulation">
289	>	depends="compile-emulation"
290	>	if="build.emulation.true">
291	>
292
293	<	<jar destfile="${product.jar}" update="true" duplicate="add">
293	>	<jar destfile="${product.jar}" duplicate="add">
294	>	<fileset dir="${build.classes.dir}">
295	>	<patternset refid="emulation.excludes"/>
296	>	</fileset>
297		<fileset dir="${build.emulation.dir}"/>
298		</jar>
299
#	Line 399 | Line 328 | ant [target], where target is one of:
328
329		<copy todir="${build.filter.src.dir}">
330		<fileset dir="${src.dir}">
331	+	<include name="**/*.html"/>
332	+	</fileset>
333	+	</copy>
334	+
335	+	<!-- Not needed now, used for doccheck filtering:
336	+	<property name="generic.declarations"
337	+	value="public interface E {} public interface T {} public interface K {} public interface V {}"
338	+	/>
339	+	-->
340	+
341	+	<copy todir="${build.filter.src.dir}">
342	+	<fileset dir="${src.dir}">
343	+	<exclude name="**/*.html"/>
344		<patternset refid="emulation.excludes"/>
345		</fileset>
346		<filterchain>
347	+
348	+	<!--
349	+	# This filter gets rid of angle-bracketed type parameters
350	+	# so that javadoc can run on the result. The following
351	+	# heuristic seems to work:
352	+	#
353	+	# For all lines not starting with space(s)-asterisk-space(s),
354	+	#   replace <something> with a space, where there may be more
355	+	#   than one right angle bracket at the end, and "something"
356	+	#   must not contain parens or pipes. (This may need some
357	+	#   tweaking.)
358	+	-->
359	+
360		<filterreader classname="jsr166.ant.filters.ReplaceFilter"
361		classpath="${build.ant.dir}">
407	–	<!--
408	–	# These arguments are to get rid of angle-bracketed type
409	–	# parameters so that javadoc can run on the result. The
410	–	# following heuristic that seems to work:
411	–	#
412	–	# For all lines not starting with space(s)-asterisk-space(s),
413	–	#   replace <something> with a space, where there may be more
414	–	#   than one right angle bracket at the end, and "something"
415	–	#   must not contain parens or pipes. (This may need some
416	–	#   tweaking.)
417	–	-->
362		<param name="notmatching" value="^\s+\*\s.*$"/>
363	<	<param name="pattern" value="&lt;[^|>()]+?>+"/>
363	>	<param name="pattern"     value="&lt;[^|>()]+?>+"/>
364		<param name="replacement" value=" "/>
365		</filterreader>
366	+
367	+
368	+	<!--
369	+	# This filter uncomments lines beginning with "//@" so that
370	+	# javadoc can see imports that are needed to resolve links
371	+	# but that shouldn't be in the compiled code.
372	+	-->
373	+
374		<filterreader classname="jsr166.ant.filters.ReplaceFilter"
375		classpath="${build.ant.dir}">
376	<	<!--
377	<	# These arguments are to uncomment lines beginning with
426	<	# "//@" so that javadoc can see imports that are needed
427	<	# to resolve links but that shouldn't be in the compiled
428	<	# code.
429	<	-->
430	<	<param name="matching" value="^//@.*$"/>
431	<	<param name="pattern" value="^//@"/>
376	>	<param name="matching"    value="^//@.*$"/>
377	>	<param name="pattern"     value="^//@"/>
378		<param name="replacement" value=""/>
379		</filterreader>
380	+
381	+
382	+	<!--
383	+	# The next two filters try to make the source look like
384	+	# something that doccheck can process. The first removes
385	+	# -source 1.4 assertions and the second adds in a bunch
386	+	# of single letter public nested marker interfaces so that
387	+	# the generic type parameters are recognized.
388	+	#
389	+	# Currently commented out because doccheck doesn't work. :-(
390	+	-->
391	+
392	+	<!--
393	+	<filterreader classname="jsr166.ant.filters.ReplaceFilter"
394	+	classpath="${build.ant.dir}">
395	+	<param name="matching"    value="^\s*assert[\s ].*$"/>
396	+	<param name="pattern"     value="assert"/>
397	+	<param name="replacement" value="//assert"/>
398	+	</filterreader>
399	+
400	+	<filterreader classname="jsr166.ant.filters.ReplaceFilter"
401	+	classpath="${build.ant.dir}">
402	+	<param name="matching"    value="^(.*(class|interface|implements) .*|)\{.*$"/>
403	+	<param name="pattern"     value="$"/>
404	+	<param name="replacement" value=" ${generic.declarations}"/>
405	+	</filterreader>
406	+	-->
407	+
408		</filterchain>
409		</copy>
410
#	Line 442 | Line 416 | ant [target], where target is one of:
416
417		<mkdir dir="${build.testcases.dir}"/>
418
419	+	<!--
420	+	<echo>javac ${gjc.args}</echo>
421	+	<echo>bootclasspath=${test.compile.bootclasspath}</echo>
422	+	<echo>classpath="${test.classpath}"</echo>
423	+	-->
424	+
425		<javac srcdir="${test.src.dir}"
426		destdir="${build.testcases.dir}"
427		debug="${build.debug}"
#	Line 450 | Line 430 | ant [target], where target is one of:
430		source="${build.sourcelevel}"
431		fork="true">
432
433	<	<bootclasspath refid="javac.bootclasspath"/>
434	<	<compilerarg line="${javac.args} ${build.warnings.option}"/>
435	<	<classpath refid="test.classpath"/>
433	>	<compilerarg    line="${gjc.args}"/>
434	>	<bootclasspath refid="test.compile.bootclasspath"/>
435	>	<classpath     refid="test.classpath"/>
436
437		</javac>
438
#	Line 474 | Line 454 | ant [target], where target is one of:
454		dir="${build.reports.dir}"
455		fork="true">
456
457	<	<jvmarg value="${test.javac.args}"/>
457	>	<jvmarg value="-Xbootclasspath/p:${test.run.bootclasspath}"/>
458
459		<formatter type="xml"/>
460
#	Line 515 | Line 495 | ant [target], where target is one of:
495		</target>
496
497
498	<	<target name="check-junit">
498	>	<target name="configure-compiler">
499	>
500	>	<property name="gjc.version"
501	>	value="2.0"/>
502	>
503	>	<condition property="novariance.arg" value="-novariance">
504	>	<and>
505	>	<equals arg1="${gjc.version}" arg2="2.0"/>
506	>	<or>
507	>	<not><isset property="gjc.novariance"/></not>
508	>	<istrue value="${gjc.novariance}"/>
509	>	</or>
510	>	</and>
511	>	</condition>
512	>
513	>	<property name="novariance.arg"
514	>	value=""/>
515	>
516	>	<property name="gjc.dir"
517	>	value="${lib.dir}/gjc"/>
518	>
519	>	<property name="javac.jar"
520	>	location="${gjc.dir}/${gjc.version}/javac.jar"/>
521	>
522	>	<property name="collect.jar"
523	>	location="${gjc.dir}/${gjc.version}/collect${novariance.arg}.jar"/>
524	>
525	>
526	>	<condition property="warnunchecked.arg" value="-warnunchecked">
527	>	<istrue value="${gjc.warnunchecked}"/>
528	>	</condition>
529	>
530	>	<property name="warnunchecked.arg" value=""/>
531	>
532	>	<condition property="prepare.src.dir" value="${build.dir}/prepare-src">
533	>	<istrue value="${build.nothreads}"/>
534	>	</condition>
535	>
536	>
537	>	<!--
538	>	! Bootclasspath munging for source compilation.
539	>	-->
540	>
541	>	<path id="pre.bootclasspath">
542	>	<pathelement location="${javac.jar}"/>
543	>	</path>
544	>
545	>	<path id="compile.bootclasspath">
546	>	<pathelement location="${build.classes.dir}"/>
547	>	<pathelement location="${collect.jar}"/>
548	>	<pathelement location="${rt.jar}"/>
549	>	</path>
550	>
551	>	<!-- Flatten paths into platform-appropriate strings -->
552	>	<property name="pre.bootclasspath"     refid="pre.bootclasspath"/>
553	>	<property name="compile.bootclasspath" refid="compile.bootclasspath"/>
554	>
555	>
556	>	<!-- Common options in javac invocations -->
557	>	<property name="gjc.args"
558	>	value="-J-Xbootclasspath/p:${pre.bootclasspath} ${warnunchecked.arg} ${novariance.arg}"
559	>	/>
560	>
561	>	</target>
562	>
563	>
564	>	<target name="prepare-src"
565	>	depends="configure-compiler"
566	>	if="prepare.src.dir">
567	>
568	>	<mkdir dir="${prepare.src.dir}"/>
569	>	<copy todir="${prepare.src.dir}">
570	>	<fileset dir="${src.dir}">
571	>	<exclude name="java/lang/**"/>
572	>	</fileset>
573	>	</copy>
574	>
575	>	</target>
576	>
577	>
578	>	<target name="configure-emulation">
579	>
580	>	<condition property="build.emulation.true">
581	>	<or>
582	>	<and>
583	>	<os family="windows"/>
584	>	<not>
585	>	<isset property="build.emulation"/>
586	>	</not>
587	>	</and>
588	>	<istrue value="${build.emulation}"/>
589	>	</or>
590	>	</condition>
591	>
592	>	</target>
593	>
594	>
595	>	<target name="configure-tests"
596	>	depends="configure-compiler">
597
598		<!-- junit.framework.Protectable is in JUnit 3.8.1 but not in 3.7 -->
599		<available property="junit.available"
#	Line 524 | Line 602 | ant [target], where target is one of:
602		<fail message="Need JUnit 3.8.1 in ${ant.home}${file.separator}lib to run tests"
603		unless="junit.available"/>
604
605	+
606	+	<!--
607	+	! Bootclasspath munging for testing, so JUnit can test our local
608	+	! modifications to java.*.
609	+	-->
610	+
611	+	<path id="test.classpath">
612	+	<pathelement location="${product.jar}"/>
613	+	<pathelement location="${build.testcases.dir}"/>
614	+	<pathelement location="${junit.jar}"/>
615	+	</path>
616	+
617	+	<path id="test.compile.bootclasspath">
618	+	<pathelement location="${javac.jar}"/>
619	+	<pathelement location="${collect.jar}"/>
620	+	<pathelement location="${rt.jar}"/>
621	+	</path>
622	+
623	+	<path id="test.run.bootclasspath">
624	+	<pathelement location="${javac.jar}"/>
625	+	<path refid="test.classpath"/>
626	+	</path>
627	+
628	+	<!-- Flatten test classpaths into platform-appropriate strings -->
629	+	<property name="test.classpath"             refid="test.classpath"/>
630	+	<property name="test.compile.bootclasspath" refid="test.compile.bootclasspath"/>
631	+	<property name="test.run.bootclasspath"     refid="test.run.bootclasspath"/>
632	+
633		</target>
634
635

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines