# RELAX NG schema for Apache Ant build files.
#
# Copyright 2009 Jarno Elovirta <http://www.elovirta.com/>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
namespace a = "http://relaxng.org/ns/compatibility/annotations/1.0"
namespace comparators = "antlib:org.apache.tools.ant.types.resources.comparators"
boolean = "true" | "false" | "on" | "off" | "yes" | "no"
id.type = xsd:NCName #xsd:ID
idref.type = xsd:NCName #xsd:IDREF
att.id = attribute id { text }
att.refid = attribute refid { text }
att.unless = attribute unless { text }
att.if = attribute if { text }
att.file = attribute file { text }
att.dir = attribute dir { text }
att.path = attribute path { text }
att.location = attribute location { text }
att.followsymlinks = attribute followsymlinks { boolean }
att.casesensitive = attribute casesensitive { boolean }
att.excludes = attribute excludes { text }
att.includes = attribute includes { text }
att.excludesfile = attribute excludesfile { text }
att.includesfile = attribute includesfile { text }
att.description = attribute description { text }
att.name = attribute name { text }
att.defaultexcludes = attribute defaultexcludes { boolean }
task.att.global =
(
att.id?,
att.description?,
attribute taskname { text }?
)
conditions =
condition.core.isfalse
| condition.core.isreference
| condition.core.equals
| condition.core.available
| condition.core.not
| condition.core.contains
| condition.core.os
| condition.core.or
| condition.core.and
| condition.core.xor
| condition.core.issigned
| condition.core.isfileselected
| condition.core.typefound
| condition.core.scriptcondition
| condition.core.parsersupports
| condition.core.isreachable
| condition.core.length
| condition.core.isfailure
| condition.core.resourcecount
| condition.core.resourcesmatch
| condition.core.hasmethod
| condition.core.matches
| condition.core.antversion
| condition.core.hasfreespace
| condition.core.filesmatch
| condition.core.checksum
| condition.core.istrue
| condition.core.isset
| condition.core.socket
| condition.core.http
| condition.core.uptodate
selector.container.group =
selector.container.and
| selector.container.majority
| selector.container.none
| selector.container.not
| selector.container.or
| selector.container.selector
selector.core.group =
selector.core.contains
| selector.core.date
| selector.core.depend
| selector.core.depth
| selector.core.different
| selector.core.filename
| selector.core.present
| selector.core.containsregexp
| selector.core.size
| selector.core.type
| selector.core.modified
| selector.core.signedselector
| selector.core.scriptselector
compararator.group =
compararator.name
| compararator.exists
| compararator.date
| compararator.type
| compararator.size
| compararator.content
| compararator.reverse
compararator.name =
element comparators:name {
empty
}
compararator.exists =
element comparators:exists {
empty
}
compararator.date =
element comparators:date {
empty
}
compararator.type =
element comparators:type {
empty
}
compararator.size =
element comparators:size {
empty
}
compararator.content =
element comparators:content {
empty
}
compararator.reverse =
element comparators:reverse {
empty
}
patterns.group =
\include
| exclude
| includesfile
| excludesfile
| patternset
| invert
resource-collection.group =
fileset
| dirset
| filelist
| path
| tar.tarfileset
| zip.zipfileset
| propertyset
| concat
| resources
| files
| restrict
| sort
| first
| last
| tokens
| union
| intersect
| difference
att.patterns.group =
att.excludes?,
att.includes?,
att.excludesfile?,
att.includesfile?
tasks =
propertyfile
| cvspass
| sshexec
| dirname
| replaceregexp
| sleep
| jarlib-display
| dependset
| patch
| jspc
| nice
| tstamp
| unwar
| icontract
| install4j
| scp
| sync
| translate
| signjar
| chown
| vajload
| jarlib-available
| buildnumber
| jpcovmerge
| stlist
| sequential
| serverdeploy
| property
| copydir
| wljspc
| fixcrlf
| record
| jar.manifest
| maudit
| antlr
| netrexxc
| jpcovreport
| native2ascii
| starteam
| input
| presetdef
| rmic
| checksum
| loadfile
| stylebook
| mimemail
| stlabel
| touch
| parallel
| splash
| antcall
| typedef
| filter
| import
| symlink
| antstructure
| script
| rpm
| replace
| mmetrics
| attrib
| loadproperties
| echoproperties
| stcheckin
| chgrp
| vajexport
| stcheckout
| whichresource
| copyfile
| macrodef
| condition
| junitreport
| taskdef
| renameext
| basename
| vajimport
| setproxy
| jarlib-resolve
| jlink
| cvstagdiff
| chmod
| jarlib-manifest
| sound
| scriptdef
| defaultexcludes
| mparse
| deltree
types =
patternset
| assertions
| propertyset
| filtermapper
| filterset
| libfileset
| condition.core.isfileselected
| mergemapper
| identitymapper
| filterreader
| scriptfilter
| unpackagemapper
| concatfilter
| extension
| fileset
| dirset
| globmapper
| filelist
| filterchain
| path
| compositemapper
| classfileset
| regexpmapper
| selector.container.selector
| xmlcatalog
| flattenmapper
| description
| chainedmapper
| packagemapper
| mapper
| zip.zipfileset
| substitution
| extensionSet
| redirector
| regexp
resource.types =
resource
| bzip2resource
| file
| gzipresource
| javaresource
| propertyresource
| \string
| tarentry
| url
| zipentry
start = project
project =
element project {
att.name?,
attribute default { text }?,
attribute basedir { text }?,
(target | tasks | types)*
}
target =
element target {
att.id?,
att.name,
att.if?,
att.unless?,
attribute depends { text }?,
att.description?,
(tasks | types)*
}
patternset =
element patternset {
att.id?,
att.refid?,
att.description?,
att.patterns.group,
patterns.group*
}
invert =
element invert {
patternset
}
\include =
element include {
att.id?,
att.name,
att.unless?,
att.if?
}
exclude =
element exclude {
att.id?,
att.name,
att.unless?,
att.if?
}
excludesfile =
element excludesfile {
att.id?,
att.name,
att.unless?,
att.if?
}
includesfile =
element includesfile {
att.id?,
att.name,
att.unless?,
att.if?
}
assertions =
element assertions {
att.id?,
att.refid?,
att.description?,
attribute enablesystemassertions { boolean }?,
(disable | enable)*
}
disable =
element disable {
att.id?,
attribute package { text }?,
attribute class { text }?,
empty
}
enable =
element enable {
att.id?,
attribute package { text }?,
attribute class { text }?,
empty
}
propertyset =
element propertyset {
att.id?,
att.refid?,
att.description?,
attribute dynamic { boolean }?,
attribute negate { boolean }?,
(propertyref
| propertyset
| mapper)*
}
propertyref =
element propertyref {
att.id?,
att.name?,
attribute builtin { "all" | "system" | "commandline" }?,
attribute regex { text }?,
attribute prefix { text }?,
empty
}
mapper =
element mapper {
att.id?,
attribute classpath { text }?,
attribute classpathref { idref.type }?,
attribute type {
"identity"
| "flatten"
| "glob"
| "merge"
| "regexp"
| "package"
| "unpackage"
}?,
att.refid?,
att.description?,
attribute classname { text }?,
attribute to { text }?,
attribute from { text }?,
(classpath | mapper)*
}
fileset =
## A FileSet is a group of files. These files can be found in a directory tree starting in a base directory and are matched by patterns taken from a number of PatternSets and Selectors.
element fileset {
fileset.type
}
classpath =
element classpath {
path.type
}
fileset.type =
(
att.id?,
att.refid?,
att.file?,
att.dir?,
att.defaultexcludes?,
att.followsymlinks?,
att.casesensitive?,
att.description?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom)*
)
custom =
element custom {
att.id?,
attribute classpath { text }?,
attribute error { text }?,
attribute classpathref { idref.type }?,
att.refid?,
att.description?,
attribute classname { text }?,
(classpath | param)*
}
param =
element param {
att.id?,
att.name?,
attribute type { text }?,
attribute value { text }?,
att.location?,
empty
}
selector.core.present =
element present {
att.id?,
attribute error { text }?,
attribute targetdir { text }?,
att.refid?,
att.description?,
attribute present { "srconly" | "both" }?,
mapper*
}
selector.container.none =
element none {
att.id?,
attribute error { text }?,
att.refid?,
att.description?,
(selector.core.group
| selector.container.group
| custom)*
}
selector.container.not =
element not {
att.id?,
attribute error { text }?,
att.refid?,
att.description?,
(selector.core.group
| selector.container.group
| custom
| condition.core.equals
| condition.core.isset)*
}
condition.core.not =
## The <not> element expects exactly one other condition to be nested into this element, negating the result of the condition.
element not {
conditions
}
selector.core.type =
element type {
att.id?,
attribute error { text }?,
att.refid?,
attribute type { "file" | "dir" }?,
att.description?,
empty
}
selector.core.modified =
element modified {
att.id?,
attribute comparator { "equal" | "rule" }?,
attribute seldirs { boolean }?,
attribute algorithm { "hashvalue" | "digest" }?,
attribute cache { "propertyfile" }?,
attribute error { text }?,
att.refid?,
att.description?,
attribute update { boolean }?,
param*
}
selector.core.signedselector =
## The <signedselector> tag selects signed files and optionaly signed with a certain name.
element signedselector {
## The signature name to check for.
att.name?
}
selector.core.scriptselector =
## The <scriptselector> element enables you to write a complex selection algorithm in any Apache BSF or JSR 223 supported language.
element scriptselector {
## The signature name to check for.
att.name?
}
selector.container.or =
element or {
att.id?,
attribute error { text }?,
att.refid?,
att.description?,
(selector.core.group
| selector.container.group
| custom
| condition.core.equals)*
}
condition.core.or =
## This condition is true if at least one of its contained conditions is, conditions will be evaluated in the order they have been specified in the build file.
element or {
conditions+
}
selector.core.contains =
## The <contains> tag in a FileSet limits the files defined by that fileset to only those which contain the string specified by the text attribute. .
element contains {
att.id?,
attribute language { text },
attribute manager { "bfs" | "javax" | "auto" }?,
attribute src { text }?,
attribute setbean { boolean }?,
attribute classpath { text }?,
attribute classpathref { text }?,
classpath
}
condition.core.contains =
element contains {
## The string to search in.
attribute string { text },
## The string to search for.
attribute substring { text },
## Perform a case sensitive comparision.
att.casesensitive?
}
selector.core.depend =
element depend {
att.id?,
attribute error { text }?,
attribute targetdir { text }?,
att.refid?,
att.description?,
attribute granularity { text }?,
mapper*
}
selector.core.different =
element different {
att.id?,
attribute ignorecontents { boolean }?,
attribute error { text }?,
attribute targetdir { text }?,
att.refid?,
att.description?,
attribute ignorefiletimes { boolean }?,
attribute granularity { text }?,
mapper*
}
selector.core.size =
element size {
att.id?,
attribute when { "less" | "more" | "equal" }?,
attribute units {
"K"
| "k"
| "kilo"
| "KILO"
| "Ki"
| "KI"
| "ki"
| "kibi"
| "KIBI"
| "M"
| "m"
| "mega"
| "MEGA"
| "Mi"
| "MI"
| "mi"
| "mebi"
| "MEBI"
| "G"
| "g"
| "giga"
| "GIGA"
| "Gi"
| "GI"
| "gi"
| "gibi"
| "GIBI"
| "T"
| "t"
| "tera"
| "TERA"
| "Ti"
| "TI"
| "ti"
| "tebi"
| "TEBI"
}?,
attribute error { text }?,
att.refid?,
att.description?,
attribute value { text }?,
empty
}
selector.container.majority =
element majority {
att.id?,
attribute error { text }?,
att.refid?,
attribute allowtie { boolean }?,
att.description?,
(selector.core.group | selector.container.group | custom)*
}
selector.core.containsregexp =
element containsregexp {
att.id?,
attribute error { text }?,
att.refid?,
att.description?,
attribute expression { text }?,
empty
}
selector.core.filename =
element filename {
att.id?,
attribute error { text }?,
att.casesensitive?,
att.name?,
att.refid?,
att.description?,
attribute negate { boolean }?,
empty
}
selector.container.selector =
element selector {
att.id?,
attribute error { text }?,
att.refid?,
att.description?,
att.unless?,
att.if?,
(selector.core.group | selector.container.group | custom)*
}
selector.core.date =
element date {
att.id?,
att.refid?,
attribute millis { text }?,
attribute checkdirs { boolean }?,
attribute datetime { text }?,
attribute granularity { text }?,
attribute pattern { text }?,
attribute when { "before" | "after" | "equal" }?,
attribute error { text }?,
att.description?,
empty
}
condition.core.xor =
element xor {
conditions
}
condition.core.issigned =
## Test whether a jarfile is signed.
element issigned {
attribute file { text },
attribute name { text }?
}
condition.core.typefound =
## Test whether a given type is defined, and that its implementation class can be loaded.
element typefound {
## name of the type
attribute name { text },
## The uri that this type lives in.
attribute uri { text}?
}
condition.core.scriptcondition =
## Evaluate a condition based on a script in any Apache BSF or JSR 223 supported language.
element scriptcondition {
## script language
attribute language { text },
## The script engine manager to use. See the script task for using this attribute.
attribute manager { text }?,
## default boolean value
attribute value { boolean }?,
## filename of script source
attribute src { text }?,
## whether to have all properties, references and targets as global variables in the script.
attribute setbeans { boolean }?,
## The classpath to pass into the script.
attribute classpath { text }?,
## The classpath to use, given as a reference to a path defined elsewhere.
attribute classpathref { text }?
}
condition.core.parsersupports =
## Tests whether Ant's XML parser supports a given feature or property, as per the SAX/JAXP specifications, by attempting to set the appropriate property/feature/
element parsersupports {
((attribute property { text }, attribute value { text })
| attribute feature { text })
}
condition.core.isreachable =
## Uses Java1.5+ networking APIs to probe for a (remote) system being reachable.
element isreachable {
(## host to check for
attribute host { text } |
## URL containing hostname
attribute url { text }),
## timeout in seconds
attribute timeout { text }
}
condition.core.isfailure =
## Test the return code of an executable (see the Exec task) for failure.
element isfailure {
## The return code to test.
attribute code { text }
}
condition.core.resourcesmatch =
## Test resources for matching.
element resourcesmatch {
## Whether to ignore line endings when comparing resource content; defaults to false, while true triggers a binary comparison
attribute astext { boolean }?
}
condition.core.hasmethod =
## Tests for a class having a method or field.
element hasmethod {
## name of the class to load
attribute classname { text },
(## name of a field to look for
attribute field { text } |
## name of a method to look for
attribute method { text }),
## should system classes be ignored?
attribute ignoreSystemClasses { boolean }?,
## a class path
attribute classpath { text }?,
## reference to a class path
attribute classpathref { text }?
}
condition.core.matches =
##
element matches {
## The string to test.
attribute string { text },
## The regular expression pattern used to test.
attribute pattern { text },
## Perform a case sensitive match. Default is true.
attribute casesensitive { boolean }?,
## Perform a multi line match. Default is false.
attribute multiline { boolean }?,
## This allows '.' to match new lines.
attribute singleline { boolean }?
}
condition.core.hasfreespace =
## Tests a partition to see if there is enough space.
element hasfreespace {
## The partition or filesystem to check for freespace
attribute partition { text },
## The amount of freespace needed.
attribute needed { text }
}
selector.container.and =
element and {
att.id?,
attribute error { text }?,
att.refid?,
att.description?,
(selector.core.group
| selector.container.group
| condition.core.available
| custom
| condition.core.uptodate
| condition.core.os
| condition.core.isset)*
}
condition.core.and =
## This condition is true if all of its contained conditions are, conditions will be evaluated in the order they have been specified in the build file.
element and {
conditions+
}
selector.core.depth =
element depth {
att.id?,
attribute max { text }?,
attribute error { text }?,
attribute min { text }?,
att.refid?,
att.description?,
empty
}
dirset =
element dirset {
att.id?,
att.refid?,
att.file?,
att.dir?,
att.defaultexcludes?,
att.followsymlinks?,
att.casesensitive?,
att.description?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom)*
}
extdirs =
element extdirs {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
existing =
element existing {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
filelist =
element filelist {
att.id?,
att.dir?,
att.refid?,
att.description?,
attribute files { text }?,
file*
}
resource =
## A basic resource.
element resource {
## The name of this resource
att.name?,
## Whether this resource exists
attribute exists { boolean }?,
## The last modification time of this resource
attribute lastmodified { xsd:long }?,
## Whether this resource is directory-like
attribute directory { boolean }?,
## The size of this resource
attribute size { xsd:long }?
}
file =
## Represents a file accessible via local filesystem conventions.
element file {
att.id?,
att.name?,
## The file represented by this resource
att.file?,
## The base directory of this resource.
attribute basedir { text }?,
empty
}
javaresource =
## Represents a resource loadable via a Java classloader.
element javaresource {
## The name of the resource.
attribute name { text },
## the classpath to use when looking up a resource.
attribute classpath { text }?,
## the classpath to use when looking up a resource, given as reference to a <path> defined elsewhere.
attribute classpathref { text }?,
## the name of the loader that is used to load the resource, constructed from the specified classpath.
attribute loaderRef { text }?
}
zipentry =
## Represents an entry in a ZIP archive.
element zipentry {
## The name of the archived resource
attribute name { text },
## The encoding of the zipfile
attribute encoding { text }?,
(
## The zip file containing this resource
attribute zipfile { text } |
resource.types
)
}
tarentry =
## Represents an entry in a TAR archive.
element tarentry {
## The name of the archived resource
attribute name { text },
(
## The tar archive containing this resource
attribute archive { text }
| resource.types
)
}
gzipresource =
## This is not a stand-alone resource, but a wrapper around another resource providing compression of the resource's contents on the fly.
element gzipresource {
resource.types
}
bzip2resource =
## This is not a stand-alone resource, but a wrapper around another resource providing compression of the resource's contents on the fly.
element bzip2resource {
resource.types
}
url =
## Represents a URL.
element url {
(
## The url to expose
attribute url { text } |
## The file to expose as a file: url
attribute file { text }
)
}
\string =
## Represents a Java String
element string {
attribute value { text }?
}
propertyresource =
## Represents an Ant property.
element propertyresource {
## The property name
attribute name { text }
}
pathelement =
element pathelement {
att.id?,
att.location?,
att.path?,
empty
}
path.type =
(
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
)
path =
element path {
path.type
}
resources =
## A generic resource collection, designed for use with references.
element resources {
att.id?,
att.refid?,
resource-collection.group*
}
files =
## A group of files. These files are matched by absolute patterns taken from a number of PatternSets.
element files {
att.patterns.group,
att.defaultexcludes?,
att.casesensitive?,
att.followsymlinks?
}
restrict =
## Restricts a nested resource collection using resource selectors
element restrict {
## Whether to cache results; disabling may seriously impact performance
attribute cache { boolean }?,
(selector.container.group
| selector.core.group)+
}
sort =
## Sorts a nested resource collection according to the resources' natural order, or by one or more nested resource comparators
element sort {
## Whether to cache results; disabling may seriously impact performance
attribute cache { boolean }?,
compararator.group+
}
first =
## Includes the first count resources from a nested resource collection.
element first {
## Whether to cache results; disabling may seriously impact performance
attribute cache { boolean }?,
## The number of resources to include
attribute count { xsd:integer }?,
resource-collection.group
}
last =
## Includes the last count resources from a nested resource collection.
element last {
## Whether to cache results; disabling may seriously impact performance
attribute cache { boolean }?,
## The number of resources to include
attribute count { xsd:integer }?,
resource-collection.group
}
tokens =
## Includes the string tokens gathered from a nested resource collection.
element tokens {
## Whether to cache results; disabling may seriously impact performance
attribute cache { boolean }?,
## The encoding of the nested resources
attribute encoding { text }?,
(resource-collection.group
& (linetokenizer | filetokenizer | stringtokenizer))
}
intersect =
## Union of nested resource collections.
element intersect {
## Whether to cache results; disabling may seriously impact performance
attribute cache { boolean }?,
resource-collection.group+
}
union =
## Intersection of nested resource collections.
element union {
## Whether to cache results; disabling may seriously impact performance
attribute cache { boolean }?,
resource-collection.group+
}
difference =
## Difference of nested resource collections.
element difference {
## Whether to cache results; disabling may seriously impact performance
attribute cache { boolean }?,
resource-collection.group+
}
filtermapper =
element filtermapper {
att.id?,
att.refid?,
att.description?,
attribute to { text }?,
attribute from { text }?,
(headfilter
| classconstants
| linecontains
| filterreader
| replaceregex
| replacetokens
| escapeunicode
| ignoreblank
| tailfilter
| tabstospaces
| prefixlines
| trim
| expandproperties
| striplinebreaks
| replacestring
| striplinecomments
| tokenfilter
| stripjavacomments
| containsregex
| deletecharacters
| linecontainsregexp)*
}
headfilter =
element headfilter {
att.id?,
attribute lines { text }?,
attribute skip { text }?,
empty
}
classconstants =
element classconstants {
att.id?,
empty
}
linecontains =
element linecontains {
att.id?,
selector.core.contains*
}
filterreader =
element filterreader {
att.id?,
attribute classpath { text }?,
attribute classpathref { idref.type }?,
att.refid?,
att.description?,
attribute classname { text }?,
(classpath | param)*
}
replaceregex =
element replaceregex {
att.id?,
attribute flags { text }?,
attribute byline { boolean }?,
attribute replace { text }?,
attribute pattern { text }?,
empty
}
replacetokens =
element replacetokens {
att.id?,
attribute begintoken { text }?,
attribute endtoken { text }?,
\token*
}
\token =
element token {
att.id?,
attribute key { text }?,
attribute value { text }?,
empty
}
escapeunicode =
element escapeunicode {
att.id?,
empty
}
ignoreblank =
element ignoreblank {
att.id?,
attribute byline { boolean }?,
empty
}
tailfilter =
element tailfilter {
att.id?,
attribute lines { text }?,
attribute skip { text }?,
empty
}
tabstospaces =
element tabstospaces {
att.id?,
attribute tablength { text }?,
empty
}
prefixlines =
element prefixlines {
att.id?,
attribute prefix { text }?,
empty
}
trim =
element trim {
att.id?,
attribute byline { boolean }?,
empty
}
expandproperties =
element expandproperties {
att.id?,
empty
}
striplinebreaks =
element striplinebreaks {
att.id?,
attribute linebreaks { text }?,
empty
}
replacestring =
element replacestring {
att.id?,
attribute byline { boolean }?,
attribute to { text }?,
attribute from { text }?,
empty
}
striplinecomments =
element striplinecomments {
att.id?,
comment*
}
comment =
element comment {
att.id?,
attribute value { text }?,
empty
}
tokenfilter =
element tokenfilter {
att.id?,
attribute delimoutput { text }?,
(containsstring
| linetokenizer
| trim
| stringtokenizer
| replaceregex
| replacestring
| ignoreblank
| deletecharacters
| containsregex
| filetokenizer)*
}
containsstring =
element containsstring {
att.id?,
attribute contains { text }?,
empty
}
linetokenizer =
element linetokenizer {
att.id?,
attribute includedelims { boolean }?,
empty
}
stringtokenizer =
element stringtokenizer {
att.id?,
attribute suppressdelims { boolean }?,
attribute includedelims { boolean }?,
attribute delimsaretokens { boolean }?,
attribute delims { text }?,
empty
}
deletecharacters =
element deletecharacters {
att.id?,
attribute chars { text }?,
empty
}
containsregex =
element containsregex {
att.id?,
attribute flags { text }?,
attribute byline { boolean }?,
attribute replace { text }?,
attribute pattern { text }?,
empty
}
filetokenizer =
element filetokenizer {
att.id?,
empty
}
stripjavacomments =
element stripjavacomments {
att.id?,
empty
}
linecontainsregexp =
element linecontainsregexp {
att.id?,
regexp*
}
regexp =
element regexp {
att.id?,
att.refid?,
att.description?,
attribute pattern { text }?,
empty
}
filterset =
element filterset {
att.id?,
attribute begintoken { text }?,
attribute endtoken { text }?,
att.refid?,
att.description?,
attribute recurse { boolean }?,
attribute filtersfile { text }?,
(filterset | filter | filtersfile)*
}
filter =
element filter {
att.id?,
attribute token { text }?,
attribute value { text }?,
empty
}
filtersfile =
element filtersfile {
att.id?,
att.file?,
empty
}
libfileset =
element libfileset {
att.id?,
att.refid?,
attribute urlbase { text }?,
attribute includeimpl { boolean }?,
att.file?,
att.dir?,
att.defaultexcludes?,
att.followsymlinks?,
attribute includeurl { boolean }?,
att.casesensitive?,
att.description?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom)*
}
condition.core.isfileselected =
element isfileselected {
att.id?,
att.file?,
att.refid?,
att.description?,
attribute basedir { text }?,
(selector.core.group | selector.container.group | custom)*
}
mergemapper =
element mergemapper {
att.id?,
attribute to { text }?,
attribute from { text }?,
empty
}
identitymapper =
element identitymapper {
att.id?,
attribute to { text }?,
attribute from { text }?,
empty
}
scriptfilter =
element scriptfilter {
att.id?,
attribute byline { boolean }?,
attribute token { text }?,
attribute src { text }?,
attribute language { text }?,
text
}
unpackagemapper =
element unpackagemapper {
att.id?,
attribute handledirsep { boolean }?,
att.casesensitive?,
attribute to { text }?,
attribute from { text }?,
empty
}
concatfilter =
element concatfilter {
att.id?,
attribute append { text }?,
attribute prepend { text }?,
empty
}
extension =
element extension {
att.id?,
att.refid?,
attribute implementationversion { text }?,
attribute specificationversion { text }?,
attribute extensionname { text }?,
attribute implementationvendorid { text }?,
attribute specificationvendor { text }?,
attribute implementationurl { text }?,
att.description?,
attribute implementationvendor { text }?,
empty
}
globmapper =
element globmapper {
att.id?,
attribute handledirsep { boolean }?,
att.casesensitive?,
attribute to { text }?,
attribute from { text }?,
empty
}
filterchain =
element filterchain {
att.id?,
att.refid?,
att.description?,
(headfilter
| classconstants
| linecontains
| filterreader
| replaceregex
| replacetokens
| escapeunicode
| ignoreblank
| tailfilter
| tabstospaces
| prefixlines
| trim
| expandproperties
| striplinebreaks
| replacestring
| striplinecomments
| tokenfilter
| stripjavacomments
| containsregex
| deletecharacters
| linecontainsregexp)*
}
compositemapper =
element compositemapper {
att.id?,
attribute to { text }?,
attribute from { text }?,
mapper*
}
classfileset =
element classfileset {
att.id?,
att.refid?,
att.file?,
att.dir?,
att.defaultexcludes?,
att.followsymlinks?,
attribute rootclass { text }?,
att.casesensitive?,
att.description?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| rootfileset
| root)*
}
rootfileset =
element rootfileset {
att.id?,
att.refid?,
att.file?,
att.dir?,
att.defaultexcludes?,
att.followsymlinks?,
att.casesensitive?,
att.description?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom)*
}
root =
element root {
att.id?,
attribute classname { text }?,
empty
}
regexpmapper =
element regexpmapper {
att.id?,
attribute handledirsep { boolean }?,
att.casesensitive?,
attribute to { text }?,
attribute from { text }?,
empty
}
flattenmapper =
element flattenmapper {
att.id?,
attribute to { text }?,
attribute from { text }?,
empty
}
description =
element description {
att.id?,
att.refid?,
att.description?,
text
}
chainedmapper =
element chainedmapper {
att.id?,
attribute to { text }?,
attribute from { text }?,
mapper*
}
packagemapper =
element packagemapper {
att.id?,
attribute handledirsep { boolean }?,
att.casesensitive?,
attribute to { text }?,
attribute from { text }?,
empty
}
substitution =
element substitution {
att.id?,
att.refid?,
att.description?,
attribute expression { text }?,
empty
}
extensionSet =
element extensionSet {
att.id?,
att.refid?,
att.description?,
(fileset | libfileset | extension)*
}
redirector =
element redirector {
att.id?,
att.refid?,
attribute inputencoding { text }?,
attribute append { boolean }?,
attribute createemptyfiles { boolean }?,
attribute output { text }?,
attribute outputproperty { text }?,
attribute outputencoding { text }?,
attribute errorproperty { text }?,
attribute error { text }?,
attribute inputstring { text }?,
attribute alwayslog { boolean }?,
attribute input { text }?,
att.description?,
attribute errorencoding { text }?,
attribute logerror { boolean }?,
(errorfilterchain
| outputfilterchain
| errormapper
| inputfilterchain
| outputmapper
| inputmapper)*
}
inputfilterchain =
element inputfilterchain {
att.id?,
att.refid?,
att.description?,
(headfilter
| classconstants
| linecontains
| filterreader
| replaceregex
| replacetokens
| escapeunicode
| ignoreblank
| tailfilter
| tabstospaces
| prefixlines
| trim
| expandproperties
| striplinebreaks
| replacestring
| striplinecomments
| tokenfilter
| stripjavacomments
| containsregex
| deletecharacters
| linecontainsregexp)*
}
errorfilterchain =
element errorfilterchain {
att.id?,
att.refid?,
att.description?,
(headfilter
| classconstants
| linecontains
| filterreader
| replaceregex
| replacetokens
| escapeunicode
| ignoreblank
| tailfilter
| tabstospaces
| prefixlines
| trim
| expandproperties
| striplinebreaks
| replacestring
| striplinecomments
| tokenfilter
| stripjavacomments
| containsregex
| deletecharacters
| linecontainsregexp)*
}
outputfilterchain =
element outputfilterchain {
att.id?,
att.refid?,
att.description?,
(headfilter
| classconstants
| linecontains
| filterreader
| replaceregex
| replacetokens
| escapeunicode
| ignoreblank
| tailfilter
| tabstospaces
| prefixlines
| trim
| expandproperties
| striplinebreaks
| replacestring
| striplinecomments
| tokenfilter
| stripjavacomments
| containsregex
| deletecharacters
| linecontainsregexp)*
}
errormapper =
element errormapper {
att.id?,
attribute classpath { text }?,
attribute classpathref { idref.type }?,
attribute type {
"identity"
| "flatten"
| "glob"
| "merge"
| "regexp"
| "package"
| "unpackage"
}?,
att.refid?,
att.description?,
attribute classname { text }?,
attribute to { text }?,
attribute from { text }?,
(classpath | mapper)*
}
outputmapper =
element outputmapper {
att.id?,
attribute classpath { text }?,
attribute classpathref { idref.type }?,
attribute type {
"identity"
| "flatten"
| "glob"
| "merge"
| "regexp"
| "package"
| "unpackage"
}?,
att.refid?,
att.description?,
attribute classname { text }?,
attribute to { text }?,
attribute from { text }?,
(classpath | mapper)*
}
inputmapper =
element inputmapper {
att.id?,
attribute classpath { text }?,
attribute classpathref { idref.type }?,
attribute type {
"identity"
| "flatten"
| "glob"
| "merge"
| "regexp"
| "package"
| "unpackage"
}?,
att.refid?,
att.description?,
attribute classname { text }?,
attribute to { text }?,
attribute from { text }?,
(classpath | mapper)*
}
propertyfile =
element propertyfile {
task.att.global,
att.file?,
attribute comment { text }?,
entry*
}
entry =
element entry {
att.id?,
attribute operation { text }?,
attribute default { text }?,
attribute key { text }?,
attribute type { "int" | "date" | "string" }?,
attribute unit {
"millisecond"
| "second"
| "minute"
| "hour"
| "day"
| "week"
| "month"
| "year"
}?,
attribute pattern { text }?,
attribute value { text }?,
empty
}
sql =
## Executes a series of SQL statements via JDBC to a database.
element sql {
task.att.global,
attribute onerror { "continue" | "stop" | "abort" }?,
attribute userid { text }?,
attribute password { text }?,
attribute autocommit { boolean }?,
attribute rdbms { text }?,
attribute print { boolean }?,
attribute classpathref { idref.type }?,
attribute encoding { text }?,
attribute version { text }?,
attribute url { text }?,
attribute src { text }?,
attribute output { text }?,
attribute driver { text }?,
attribute showheaders { boolean }?,
attribute classpath { text }?,
attribute delimitertype { "normal" | "row" }?,
attribute escapeprocessing { boolean }?,
attribute append { boolean }?,
attribute caching { boolean }?,
attribute keepformat { boolean }?,
attribute delimiter { text }?,
(text | fileset | classpath | sql.transaction)*
}
sql.transaction =
## Use nested <transaction> elements to specify multiple blocks of commands to the executed executed in the same connection but different transactions.
element transaction {
att.id?,
## File containing SQL statements
(attribute src { text } | text)
}
cvspass =
element cvspass {
task.att.global,
attribute password { text }?,
attribute cvsroot { text }?,
attribute passfile { text }?,
empty
}
sshexec =
element sshexec {
task.att.global,
attribute append { boolean }?,
attribute output { text }?,
attribute port { text }?,
attribute verbose { boolean }?,
attribute command { text }?,
attribute outputproperty { text }?,
attribute username { text }?,
attribute trust { boolean }?,
attribute knownhosts { text }?,
attribute keyfile { text }?,
attribute timeout { text }?,
attribute password { text }?,
attribute failonerror { boolean }?,
attribute host { text }?,
attribute passphrase { text }?,
empty
}
dirname =
## Task to determine the directory path of a specified file.
element dirname {
task.att.global,
## The path to take the dirname of.
att.file?,
## The name of the property to set.
attribute property { text }?,
empty
}
replaceregexp =
element replaceregexp {
task.att.global,
attribute flags { text }?,
attribute match { text }?,
attribute byline { boolean }?,
attribute replace { text }?,
att.file?,
attribute encoding { text }?,
(fileset | substitution | regexp)*
}
sleep =
element sleep {
task.att.global,
attribute hours { text }?,
attribute milliseconds { text }?,
attribute minutes { text }?,
attribute failonerror { boolean }?,
attribute seconds { text }?,
empty
}
jarlib-display =
element jarlib-display {
task.att.global,
att.file?,
fileset*
}
dependset =
element dependset {
task.att.global,
att.defaultexcludes?,
att.followsymlinks?,
att.casesensitive?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| targetfileset
| srcfileset
| srcfilelist
| targetfilelist)*
}
targetfileset =
element targetfileset {
att.id?,
att.refid?,
att.file?,
att.dir?,
att.defaultexcludes?,
att.followsymlinks?,
att.casesensitive?,
att.description?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom)*
}
srcfileset =
element srcfileset {
att.id?,
att.refid?,
att.file?,
att.dir?,
att.defaultexcludes?,
att.followsymlinks?,
att.casesensitive?,
att.description?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom)*
}
srcfilelist =
element srcfilelist {
att.id?,
att.dir?,
att.refid?,
att.description?,
attribute files { text }?,
file*
}
targetfilelist =
element targetfilelist {
att.id?,
att.dir?,
att.refid?,
att.description?,
attribute files { text }?,
file*
}
patch =
element patch {
task.att.global,
attribute strip { text }?,
att.dir?,
attribute destfile { text }?,
attribute quiet { boolean }?,
attribute originalfile { text }?,
attribute patchfile { text }?,
attribute reverse { boolean }?,
attribute backups { boolean }?,
attribute ignorewhitespace { boolean }?,
empty
}
jspc =
element jspc {
task.att.global,
attribute mapped { boolean }?,
attribute ieplugin { text }?,
attribute classpathref { idref.type }?,
attribute package { text }?,
attribute destdir { text }?,
attribute compilerclasspath { text }?,
att.defaultexcludes?,
att.followsymlinks?,
attribute uribase { text }?,
attribute classpath { text }?,
att.casesensitive?,
attribute verbose { text }?,
attribute compiler { text }?,
attribute webxml { text }?,
attribute failonerror { boolean }?,
attribute srcdir { text }?,
att.patterns.group,
attribute uriroot { text }?,
attribute webinc { text }?,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| compilerclasspath
| classpath
| webapp)*
}
compilerclasspath =
element compilerclasspath {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
webapp =
element webapp {
att.id?,
attribute basedir { text }?,
empty
}
factory =
element factory {
att.id?,
att.name?,
\attribute*
}
\attribute =
element attribute {
att.id?,
att.name?,
attribute value { text }?,
empty
}
outputproperty =
element outputproperty {
att.id?,
att.name?,
attribute value { text }?,
empty
}
nice =
element nice {
task.att.global,
attribute newpriority { text }?,
attribute currentpriority { text }?,
empty
}
sysproperty =
element sysproperty {
att.id?,
attribute key { text }?,
att.file?,
attribute value { text }?,
att.path?,
empty
}
bootclasspath =
element bootclasspath {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
env =
element env {
att.id?,
attribute key { text }?,
att.file?,
attribute value { text }?,
att.path?,
empty
}
syspropertyset =
element syspropertyset {
att.id?,
att.refid?,
att.description?,
attribute dynamic { boolean }?,
attribute negate { boolean }?,
(propertyref | propertyset | mapper)*
}
permissions = element permissions { att.id?, (grant | revoke)* }
grant =
element grant {
att.id?,
att.name?,
attribute class { text }?,
attribute actions { text }?,
empty
}
revoke =
element revoke {
att.id?,
att.name?,
attribute class { text }?,
attribute actions { text }?,
empty
}
jvmarg =
element jvmarg {
att.id?,
attribute line { text }?,
att.file?,
attribute pathref { idref.type }?,
attribute value { text }?,
att.path?,
empty
}
arg =
element arg {
att.id?,
attribute line { text }?,
att.file?,
attribute pathref { idref.type }?,
attribute value { text }?,
att.path?,
empty
}
testlet = element testlet { att.id?, text }
tstamp =
element tstamp {
task.att.global,
attribute prefix { text }?,
format*
}
format =
element format {
att.id?,
attribute locale { text }?,
attribute unit {
"millisecond"
| "second"
| "minute"
| "hour"
| "day"
| "week"
| "month"
| "year"
}?,
attribute timezone { text }?,
attribute pattern { text }?,
attribute property { text }?,
attribute offset { text }?,
empty
}
icontract =
element icontract {
task.att.global,
attribute classdir { text }?,
attribute quiet { boolean }?,
attribute classpathref { idref.type }?,
att.defaultexcludes?,
attribute repositorydir { text }?,
attribute instrumentdir { text }?,
att.followsymlinks?,
attribute builddir { text }?,
attribute updateicontrol { boolean }?,
attribute classpath { text }?,
att.casesensitive?,
attribute pre { boolean }?,
attribute controlfile { text }?,
attribute invariant { boolean }?,
attribute post { boolean }?,
attribute srcdir { text }?,
attribute failthrowable { text }?,
attribute verbosity { text }?,
att.patterns.group,
attribute repbuilddir { text }?,
attribute targets { text }?,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| classpath)*
}
user =
element user {
att.id?,
attribute userid { text }?,
attribute displayname { text }?,
empty
}
commandline =
element commandline {
att.id?,
attribute executable { text }?,
(marker | argument)*
}
marker =
element marker {
att.id?,
empty
}
argument =
element argument {
att.id?,
attribute line { text }?,
att.file?,
attribute pathref { idref.type }?,
attribute value { text }?,
att.path?,
empty
}
install4j =
element install4j {
task.att.global,
attribute quiet { boolean }?,
attribute verbose { boolean }?,
attribute buildselected { boolean }?,
attribute variablefile { text }?,
attribute test { boolean }?,
attribute buildids { text }?,
attribute mediatypes { text }?,
attribute destination { text }?,
attribute release { text }?,
attribute projectfile { text }?,
variable*
}
variable =
element variable {
att.id?,
att.name?,
attribute mediafileid { text }?,
attribute value { text }?,
empty
}
scp =
element scp {
task.att.global,
attribute remotetofile { text }?,
attribute password { text }?,
attribute username { text }?,
attribute localtodir { text }?,
attribute knownhosts { text }?,
attribute port { text }?,
attribute remotefile { text }?,
attribute passphrase { text }?,
attribute verbose { boolean }?,
attribute host { text }?,
attribute remotetodir { text }?,
attribute todir { text }?,
attribute failonerror { boolean }?,
attribute localtofile { text }?,
attribute localfile { text }?,
att.file?,
attribute trust { boolean }?,
attribute keyfile { text }?,
fileset*
}
sync =
element sync {
task.att.global,
attribute verbose { boolean }?,
attribute todir { text }?,
attribute overwrite { boolean }?,
attribute includeemptydirs { boolean }?,
attribute failonerror { boolean }?,
attribute granularity { text }?,
fileset*
}
translate =
## Identifies keys in files delimited by special tokens and translates them with values read from resource bundles.
element translate {
task.att.global,
attribute bundlecountry { text }?,
attribute bundlelanguage { text }?,
att.defaultexcludes?,
att.followsymlinks?,
attribute srcencoding { text }?,
attribute bundle { text },
attribute bundleencoding { text }?,
att.casesensitive?,
attribute destencoding { text }?,
attribute bundlevariant { text }?,
attribute todir { text },
att.patterns.group,
attribute endtoken { text },
attribute forceoverwrite { boolean }?,
attribute starttoken { text },
(selector.core.group
| patterns.group
| selector.container.group
| custom
| fileset)*
}
signjar =
element signjar {
task.att.global,
attribute storepass { text }?,
attribute lazy { boolean }?,
attribute jar { text }?,
attribute verbose { boolean }?,
attribute keypass { text }?,
attribute maxmemory { text }?,
attribute alias { text }?,
attribute sectionsonly { boolean }?,
attribute keystore { text }?,
attribute sigfile { text }?,
attribute internalsf { boolean }?,
attribute storetype { text }?,
attribute signedjar { text }?,
fileset*
}
chown =
element chown {
task.att.global,
attribute addsourcefile { boolean }?,
attribute verbose { boolean }?,
attribute parallel { boolean }?,
attribute input { text }?,
attribute executable { text }?,
attribute force { boolean }?,
attribute inputstring { text }?,
attribute searchpath { boolean }?,
attribute relative { boolean }?,
attribute skipemptyfilesets { boolean }?,
attribute command { text }?,
attribute forwardslash { boolean }?,
attribute spawn { boolean }?,
attribute vmlauncher { boolean }?,
att.file?,
attribute logerror { boolean }?,
attribute errorproperty { text }?,
attribute failonerror { boolean }?,
attribute output { text }?,
attribute error { text }?,
attribute os { text }?,
attribute owner { text }?,
attribute dest { text }?,
attribute resolveexecutable { boolean }?,
attribute resultproperty { text }?,
attribute ignoremissing { boolean }?,
attribute failifexecutionfails { boolean }?,
attribute append { boolean }?,
attribute timeout { text }?,
attribute maxparallel { text }?,
attribute outputproperty { text }?,
att.dir?,
attribute newenvironment { boolean }?,
attribute type { "file" | "dir" | "both" }?,
(mapper
| srcfile
| targetfile
| redirector
| filelist
| env
| fileset
| dirset
| arg)*
}
srcfile =
element srcfile {
att.id?,
empty
}
targetfile =
element targetfile {
att.id?,
empty
}
vajload =
element vajload {
task.att.global,
attribute remote { text }?,
attribute haltonerror { boolean }?,
vajproject*
}
vajproject =
element vajproject {
att.id?,
attribute version { text }?,
att.name?,
empty
}
jarlib-available =
element jarlib-available {
task.att.global,
att.file?,
attribute property { text }?,
(extensionset | extension)*
}
extensionset =
element extensionset {
att.id?,
att.refid?,
att.description?,
(fileset | libfileset | extension)*
}
jpcovmerge =
element jpcovmerge {
task.att.global,
attribute verbose { boolean }?,
attribute tofile { text }?,
attribute home { text }?,
fileset*
}
wasclasspath =
element wasclasspath {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
sequential =
element sequential {
task.att.global,
tasks*
}
serverdeploy =
element serverdeploy {
task.att.global,
attribute action { text }?,
attribute source { text }?,
(weblogic | generic | jonas)*
}
generic =
element generic {
att.id?,
attribute classpath { text }?,
attribute password { text }?,
attribute server { text }?,
attribute classname { text }?,
attribute username { text }?,
(arg | classpath | jvmarg)*
}
property =
element property {
task.att.global,
att.refid?,
attribute url { text }?,
att.name?,
attribute classpath { text }?,
att.file?,
attribute userproperty { boolean }?,
attribute resource { text }?,
attribute environment { text }?,
attribute prefix { text }?,
attribute classpathref { idref.type }?,
attribute value { text }?,
att.location?,
classpath*
}
buildpathelement =
element buildpathelement {
att.id?,
att.location?,
att.path?,
empty
}
buildpath =
element buildpath {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
wljspc =
element wljspc {
task.att.global,
attribute src { text }?,
attribute classpath { text }?,
att.defaultexcludes?,
att.followsymlinks?,
att.casesensitive?,
attribute dest { text }?,
attribute package { text }?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| classpath)*
}
fixcrlf =
## Adjusts a text file to local conventions.
element fixcrlf {
task.att.global,
(attribute srcdir { text } | att.file),
attribute tab { "add" | "asis" | "remove" }?,
att.excludes?,
attribute encoding { text }?,
attribute cr { "add" | "asis" | "remove" }?,
attribute destdir { text }?,
att.defaultexcludes?,
attribute eol {
"asis" | "cr" | "lf" | "crlf" | "mac" | "unix" | "dos"
}?,
att.followsymlinks?,
attribute javafiles { boolean }?,
attribute eof { "add" | "asis" | "remove" }?,
att.casesensitive?,
attribute tablength { text }?,
att.includes?,
attribute fixlast { boolean }?,
att.includesfile?,
att.excludesfile?,
(selector.core.group
| patterns.group
| selector.container.group
| custom)*
}
record =
element record {
task.att.global,
attribute append { boolean }?,
att.name?,
attribute loglevel {
"error" | "warn" | "info" | "verbose" | "debug"
}?,
attribute emacsmode { boolean }?,
attribute action { "start" | "stop" }?,
empty
}
exec =
element exec {
task.att.global,
attribute resultproperty { text }?,
attribute failifexecutionfails { boolean }?,
attribute command { text }?,
attribute executable { text }?,
attribute os { text }?,
attribute errorproperty { text }?,
attribute output { text }?,
attribute timeout { text }?,
attribute spawn { boolean }?,
attribute input { text }?,
attribute inputstring { text }?,
attribute searchpath { boolean }?,
attribute logerror { boolean }?,
att.dir?,
attribute error { text }?,
attribute outputproperty { text }?,
attribute resolveexecutable { boolean }?,
attribute failonerror { boolean }?,
attribute append { boolean }?,
attribute newenvironment { boolean }?,
attribute vmlauncher { boolean }?,
(arg | redirector | env)*
}
maudit =
element maudit {
task.att.global,
attribute tofile { text }?,
attribute exit { boolean }?,
attribute offsets { boolean }?,
attribute quiet { boolean }?,
attribute unused { boolean }?,
attribute verbose { boolean }?,
attribute maxmemory { text }?,
attribute fix { boolean }?,
attribute metamatahome { text }?,
attribute list { boolean }?,
attribute home { text }?,
attribute fullsemanticize { boolean }?,
(fileset
| jvmarg
| classpath
| rulespath
| searchpath
| sourcepath)*
}
rulespath =
element rulespath {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
searchpath =
element searchpath {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
netrexxc =
element netrexxc {
task.att.global,
att.excludes?,
attribute verbose {
"verbose"
| "verbose0"
| "verbose1"
| "verbose2"
| "verbose3"
| "verbose4"
| "verbose5"
| "noverbose"
}?,
attribute keep { boolean }?,
attribute comments { boolean }?,
attribute strictimport { boolean }?,
attribute sourcedir { boolean }?,
attribute diag { boolean }?,
attribute compile { boolean }?,
attribute binary { boolean }?,
att.includes?,
attribute suppressmethodargumentnotused { boolean }?,
attribute suppressvariablenotused { boolean }?,
attribute strictsignal { boolean }?,
attribute trace { "trace" | "trace1" | "trace2" | "notrace" }?,
attribute destdir { text }?,
attribute console { boolean }?,
attribute replace { boolean }?,
attribute classpath { text }?,
att.followsymlinks?,
att.casesensitive?,
att.defaultexcludes?,
attribute format { boolean }?,
attribute explicit { boolean }?,
att.includesfile?,
attribute suppressprivatepropertynotused { boolean }?,
attribute strictargs { boolean }?,
attribute suppressdeprecation { boolean }?,
attribute strictcase { boolean }?,
attribute savelog { boolean }?,
attribute logo { boolean }?,
attribute utf8 { boolean }?,
attribute strictprops { boolean }?,
attribute srcdir { text }?,
attribute java { boolean }?,
attribute suppressexceptionnotsignalled { boolean }?,
attribute crossref { boolean }?,
attribute time { boolean }?,
attribute symbols { boolean }?,
att.excludesfile?,
attribute strictassign { boolean }?,
attribute compact { boolean }?,
attribute decimal { boolean }?,
(selector.core.group
| patterns.group
| selector.container.group
| custom)*
}
ftp =
element ftp {
task.att.global,
attribute binary { boolean }?,
attribute password { text }?,
attribute userid { text }?,
attribute timediffauto { boolean }?,
attribute remotedir { text }?,
attribute separator { text }?,
attribute port { text }?,
attribute skipfailedtransfers { boolean }?,
attribute chmod { text }?,
attribute timediffmillis { text }?,
attribute verbose { boolean }?,
attribute server { text }?,
attribute newer { boolean }?,
attribute action {
"send"
| "put"
| "recv"
| "get"
| "del"
| "delete"
| "list"
| "mkdir"
| "chmod"
| "rmdir"
}?,
attribute passive { boolean }?,
attribute preservelastmodified { boolean }?,
attribute listing { text }?,
attribute umask { text }?,
attribute ignorenoncriticalerrors { boolean }?,
attribute depends { boolean }?,
fileset*
}
jpcovreport =
element jpcovreport {
task.att.global,
attribute snapshot { text }?,
attribute tofile { text }?,
attribute filters { text }?,
attribute percent { text }?,
attribute home { text }?,
attribute type {
"executive" | "summary" | "detailed" | "verydetailed"
}?,
attribute format { "html" | "text" | "xml" }?,
attribute includesource { boolean }?,
(reference | coveragepath | sourcepath)*
}
coveragepath =
element coveragepath {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
ant =
## Runs Ant on a supplied buildfile. This can be used to build subprojects.
element ant {
task.att.global,
attribute output { text }?,
attribute inheritall { boolean }?,
att.dir?,
attribute inheritrefs { boolean }?,
attribute antfile { text }?,
attribute target { text }?,
(reference | propertyset | property | target)*
}
native2ascii =
element native2ascii {
task.att.global,
attribute src { text }?,
attribute encoding { text }?,
attribute ext { text }?,
attribute implementation { text }?,
att.defaultexcludes?,
att.followsymlinks?,
attribute reverse { boolean }?,
att.casesensitive?,
attribute dest { text }?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| arg
| mapper)*
}
starteam =
element starteam {
task.att.global,
attribute targetfolderabsolute { boolean }?,
attribute force { boolean }?,
attribute recursion { boolean }?,
attribute verbose { boolean }?,
attribute username { text }?,
attribute targetfolder { text }?,
attribute viewname { text }?,
attribute projectname { text }?,
attribute servername { text }?,
attribute password { text }?,
attribute serverport { text }?,
attribute foldername { text }?,
att.excludes?,
att.includes?,
empty
}
input =
element input {
task.att.global,
attribute addproperty { text }?,
attribute defaultvalue { text }?,
attribute validargs { text }?,
attribute message { text }?,
text
}
presetdef =
element presetdef {
task.att.global,
att.name?,
attribute uri { text }?,
tasks*
}
rmic =
element rmic {
task.att.global,
attribute verify { boolean }?,
attribute iiop { boolean }?,
attribute idlopts { text }?,
attribute extdirs { text }?,
attribute sourcebase { text }?,
attribute classpathref { idref.type }?,
attribute base { text }?,
att.defaultexcludes?,
att.followsymlinks?,
attribute includeantruntime { boolean }?,
attribute includejavaruntime { boolean }?,
attribute classpath { text }?,
att.casesensitive?,
attribute debug { boolean }?,
attribute compiler { text }?,
attribute idl { boolean }?,
attribute iiopopts { text }?,
attribute classname { text }?,
att.patterns.group,
attribute filtering { boolean }?,
attribute stubversion { text }?,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| extdirs
| classpath
| compilerarg)*
}
compilerarg =
element compilerarg {
att.id?,
attribute line { text }?,
attribute implementation { text }?,
att.file?,
attribute compiler { text }?,
attribute pathref { idref.type }?,
attribute value { text }?,
att.path?,
empty
}
condition.core.checksum =
## Generates checksum for files.
element checksum {
attribute fileext { text }?,
attribute totalproperty { text }?,
attribute property { text }?,
att.defaultexcludes?,
att.followsymlinks?,
att.casesensitive?,
attribute readbuffersize { text }?,
attribute verifyproperty { text }?,
attribute todir { text }?,
attribute algorithm { text }?,
att.file?,
attribute pattern { text },
attribute format { "CHECKSUM" | "MD5SUM" | "SVF" }?,
attribute provider { text }?,
attribute forceoverwrite { boolean }?,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| fileset)*
}
checksum =
## Generates checksum for files.
element checksum {
task.att.global,
attribute fileext { text }?,
attribute totalproperty { text }?,
attribute property { text }?,
att.defaultexcludes?,
att.followsymlinks?,
att.casesensitive?,
attribute readbuffersize { text }?,
attribute verifyproperty { text }?,
attribute todir { text }?,
attribute algorithm { text }?,
att.file?,
attribute pattern { text },
attribute format { "CHECKSUM" | "MD5SUM" | "SVF" }?,
attribute provider { text }?,
attribute forceoverwrite { boolean }?,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| fileset)*
}
loadfile =
element loadfile {
task.att.global,
attribute encoding { text }?,
attribute property { text }?,
attribute srcfile { text }?,
attribute failonerror { boolean }?,
filterchain*
}
touch =
element touch {
task.att.global,
attribute verbose { boolean }?,
attribute mkdirs { boolean }?,
attribute millis { text }?,
att.file?,
attribute pattern { text }?,
attribute datetime { text }?,
(fileset | filelist | mapper)*
}
parallel =
## Executes nested tasks in parallel with no guarantees of thread safety.
element parallel {
task.att.global,
attribute pollinterval { text }?,
attribute threadsperprocessor { text }?,
attribute timeout { text }?,
attribute threadcount { text }?,
attribute failonany { boolean }?,
(tasks | parallel.daemons)*
}
parallel.daemons =
## Llist of tasks which are to be run in parallel daemon threads.
element daemons {
att.id?,
tasks*
}
splash =
element splash {
task.att.global,
attribute port { text }?,
attribute user { text }?,
attribute proxy { text }?,
attribute imageurl { text }?,
attribute password { text }?,
attribute showduration { text }?,
attribute useproxy { boolean }?,
empty
}
antcall =
## Call another target within the same buildfile optionally specifying some properties (params in this context).
element antcall {
task.att.global,
attribute inheritall { boolean }?,
attribute inheritrefs { boolean }?,
attribute target { text }?,
(reference | propertyset | target | param)*
}
typedef =
element typedef {
task.att.global,
att.name?,
attribute uri { text }?,
attribute classpath { text }?,
att.file?,
attribute classname { text }?,
attribute resource { text }?,
attribute adaptto { text }?,
attribute onerror { "fail" | "report" | "ignore" }?,
attribute loaderref { idref.type }?,
attribute classpathref { idref.type }?,
attribute adapter { text }?,
attribute format { "properties" | "xml" }?,
attribute reverseloader { boolean }?,
classpath*
}
import =
## Imports another build file into the current project.
element import {
task.att.global,
## If true, do not stop the build if the file does not exist, default is false.
attribute optional { boolean }?,
## The file to import.
att.file
}
symlink =
element symlink {
task.att.global,
attribute linkfilename { text }?,
attribute overwrite { boolean }?,
attribute link { text }?,
attribute action { text }?,
attribute resource { text }?,
attribute failonerror { boolean }?,
fileset*
}
antstructure =
## Generates an DTD for Ant buildfiles which contains information about all tasks currently known to Ant.
element antstructure {
task.att.global,
attribute output { text }?,
empty
}
script =
element script {
task.att.global,
attribute src { text }?,
attribute language { text }?,
text
}
rpm =
element rpm {
task.att.global,
attribute removesource { boolean }?,
attribute output { text }?,
attribute quiet { boolean }?,
attribute command { text }?,
attribute cleanbuilddir { boolean }?,
attribute removespec { boolean }?,
attribute error { text }?,
attribute failonerror { boolean }?,
attribute specfile { text }?,
attribute topdir { text }?,
attribute rpmbuildcommand { text }?,
empty
}
replace =
element replace {
task.att.global,
attribute encoding { text }?,
att.file?,
att.dir?,
attribute token { text }?,
attribute propertyfile { text }?,
att.defaultexcludes?,
att.followsymlinks?,
attribute summary { boolean }?,
att.casesensitive?,
attribute value { text }?,
att.patterns.group,
attribute replacefilterfile { text }?,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| replacefilter
| replacetoken
| replacevalue)*
}
replacefilter =
element replacefilter {
att.id?,
attribute token { text }?,
attribute value { text }?,
attribute property { text }?,
empty
}
replacetoken = element replacetoken { att.id?, text }
replacevalue = element replacevalue { att.id?, text }
mmetrics =
element mmetrics {
task.att.global,
attribute metamatahome { text }?,
attribute tofile { text }?,
attribute maxmemory { text }?,
attribute home { text }?,
attribute granularity {
"compilation-units" | "files" | "methods" | "types" | "packages"
}?,
(fileset | jvmarg | classpath | path | sourcepath)*
}
attrib =
element attrib {
task.att.global,
attribute addsourcefile { boolean }?,
attribute verbose { boolean }?,
attribute parallel { boolean }?,
attribute input { text }?,
attribute executable { text }?,
attribute force { boolean }?,
attribute inputstring { text }?,
attribute readonly { boolean }?,
attribute searchpath { boolean }?,
attribute relative { boolean }?,
attribute skipemptyfilesets { boolean }?,
attribute command { text }?,
attribute forwardslash { boolean }?,
attribute spawn { boolean }?,
attribute hidden { boolean }?,
attribute vmlauncher { boolean }?,
att.file?,
attribute logerror { boolean }?,
attribute errorproperty { text }?,
attribute failonerror { boolean }?,
attribute output { text }?,
attribute error { text }?,
attribute os { text }?,
attribute dest { text }?,
attribute resolveexecutable { boolean }?,
attribute resultproperty { text }?,
attribute ignoremissing { boolean }?,
attribute failifexecutionfails { boolean }?,
attribute append { boolean }?,
attribute timeout { text }?,
attribute maxparallel { text }?,
attribute system { boolean }?,
attribute outputproperty { text }?,
attribute archive { boolean }?,
att.dir?,
attribute newenvironment { boolean }?,
attribute type { "file" | "dir" | "both" }?,
(mapper
| srcfile
| targetfile
| redirector
| filelist
| env
| fileset
| dirset
| arg)*
}
condition.core.isfalse =
element isfalse {
att.id?,
attribute value { boolean }?,
empty
}
condition.core.isreference =
element isreference {
att.id?,
attribute type { text }?,
att.refid?,
empty
}
condition.core.equals =
element equals {
att.id?,
attribute trim { boolean }?,
attribute arg2 { text }?,
attribute arg1 { text }?,
att.casesensitive?,
empty
}
condition.core.available =
element available {
task.att.global,
attribute classpath { text }?,
att.file?,
attribute classname { text }?,
attribute resource { text }?,
attribute ignoresystemclasses { boolean }?,
attribute type { "file" | "dir" }?,
attribute classpathref { idref.type }?,
attribute filepath { text }?,
(classpath | filepath)*
}
filepath =
element filepath {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
condition.core.os =
element os {
att.id?,
attribute version { text }?,
att.name?,
attribute family { text }?,
attribute arch { text }?,
empty
}
condition.core.filesmatch =
element filesmatch {
att.id?,
attribute file2 { text }?,
attribute file1 { text }?,
empty
}
condition.core.istrue =
element istrue {
att.id?,
attribute value { boolean }?,
empty
}
condition.core.isset =
element isset {
att.id?,
attribute property { text }?,
empty
}
condition.core.socket =
element socket {
att.id?,
attribute port { text }?,
attribute server { text }?,
empty
}
condition.core.http =
## The http condition checks for a valid response from a web server of the specified url.
element http {
att.id?,
## The full URL of the page to request.
attribute url { text },
## The lowest HTTP response code that signals an error; by default '400'; server errors, not-authorized, not-found and the like are detected
attribute errorsbeginat { text }?
}
condition.core.uptodate =
## Sets a property if a target file or set of target files is more up-to-date than a source file or set of source files.
element uptodate {
#task.att.global,
#attribute value { text }?,
#attribute property { text }?,
attribute targetfile { text }?,
attribute srcfile { text }?,
(srcfiles | mapper)*
}
srcfiles =
element srcfiles {
att.id?,
att.refid?,
att.file?,
att.dir?,
att.defaultexcludes?,
att.followsymlinks?,
att.casesensitive?,
att.description?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom)*
}
loadproperties =
element loadproperties {
task.att.global,
attribute classpath { text }?,
attribute classpathref { idref.type }?,
attribute encoding { text }?,
attribute resource { text }?,
attribute srcfile { text }?,
(filterchain | classpath)*
}
echoproperties =
element echoproperties {
task.att.global,
attribute prefix { text }?,
attribute format { "xml" | "text" }?,
attribute srcfile { text }?,
attribute failonerror { boolean }?,
attribute destfile { text }?,
propertyset*
}
chgrp =
element chgrp {
task.att.global,
attribute addsourcefile { boolean }?,
attribute verbose { boolean }?,
attribute parallel { boolean }?,
attribute input { text }?,
attribute executable { text }?,
attribute force { boolean }?,
attribute inputstring { text }?,
attribute searchpath { boolean }?,
attribute relative { boolean }?,
attribute skipemptyfilesets { boolean }?,
attribute command { text }?,
attribute forwardslash { boolean }?,
attribute spawn { boolean }?,
attribute vmlauncher { boolean }?,
attribute group { text }?,
att.file?,
attribute logerror { boolean }?,
attribute errorproperty { text }?,
attribute failonerror { boolean }?,
attribute output { text }?,
attribute error { text }?,
attribute os { text }?,
attribute dest { text }?,
attribute resolveexecutable { boolean }?,
attribute resultproperty { text }?,
attribute ignoremissing { boolean }?,
attribute failifexecutionfails { boolean }?,
attribute append { boolean }?,
attribute timeout { text }?,
attribute maxparallel { text }?,
attribute outputproperty { text }?,
att.dir?,
attribute newenvironment { boolean }?,
attribute type { "file" | "dir" | "both" }?,
(mapper
| srcfile
| targetfile
| redirector
| filelist
| env
| fileset
| dirset
| arg)*
}
vajexport =
element vajexport {
task.att.global,
attribute exportclasses { boolean }?,
attribute haltonerror { boolean }?,
attribute remote { text }?,
attribute destdir { text }?,
att.defaultexcludes?,
attribute exportresources { boolean }?,
attribute exportsources { boolean }?,
attribute overwrite { boolean }?,
attribute exportdebuginfo { boolean }?,
att.excludes?,
att.includes?,
(\include | exclude)*
}
whichresource =
element whichresource {
task.att.global,
attribute classpath { text }?,
attribute resource { text }?,
attribute class { text }?,
attribute property { text }?,
classpath*
}
copyfile =
element copyfile {
task.att.global,
attribute forceoverwrite { boolean }?,
attribute dest { text }?,
attribute filtering { text }?,
attribute src { text }?,
empty
}
macrodef =
element macrodef {
task.att.global,
att.name?,
attribute uri { text }?,
(sequential | \element | \attribute | macrodef.text)*
}
\element =
element element {
att.id?,
attribute implicit { boolean }?,
attribute optional { boolean }?,
att.name?,
att.description?,
empty
}
macrodef.text =
element text {
att.id?,
attribute trim { boolean }?,
attribute optional { boolean }?,
att.name?,
att.description?,
empty
}
condition =
element condition {
att.id?,
attribute value { text }?,
attribute property { text }?,
attribute else { text }?,
conditions+
}
junitreport =
element junitreport {
task.att.global,
attribute todir { text }?,
attribute tofile { text }?,
(report | fileset)*
}
report =
element report {
att.id?,
attribute todir { text }?,
attribute styledir { text }?,
attribute format { "frames" | "noframes" }?,
attribute extension { text }?,
empty
}
taskdef =
element taskdef {
task.att.global,
att.name?,
attribute uri { text }?,
attribute classpath { text }?,
att.file?,
attribute classname { text }?,
attribute resource { text }?,
attribute adaptto { text }?,
attribute onerror { "fail" | "report" | "ignore" }?,
attribute loaderref { idref.type }?,
attribute classpathref { idref.type }?,
attribute adapter { text }?,
attribute format { "properties" | "xml" }?,
attribute reverseloader { boolean }?,
classpath*
}
renameext =
element renameext {
task.att.global,
attribute replace { boolean }?,
attribute toextension { text }?,
att.defaultexcludes?,
att.followsymlinks?,
attribute fromextension { text }?,
att.casesensitive?,
attribute srcdir { text }?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom)*
}
basename =
element basename {
task.att.global,
att.file?,
attribute property { text }?,
attribute suffix { text }?,
empty
}
vajimport =
element vajimport {
task.att.global,
attribute haltonerror { boolean }?,
attribute remote { text }?,
att.defaultexcludes?,
attribute importsources { boolean }?,
attribute project { text }?,
attribute importresources { boolean }?,
attribute importclasses { boolean }?,
fileset*
}
setproxy =
element setproxy {
task.att.global,
attribute nonproxyhosts { text }?,
attribute proxyhost { text }?,
attribute socksproxyhost { text }?,
attribute proxyport { text }?,
attribute socksproxyport { text }?,
attribute proxyuser { text }?,
attribute proxypassword { text }?,
empty
}
jarlib-resolve =
element jarlib-resolve {
task.att.global,
attribute checkextension { boolean }?,
attribute property { text }?,
attribute failonerror { boolean }?,
(ant | location | jarlib-resolve.url | extension)*
}
location =
element location {
att.id?,
att.location?,
empty
}
jarlib-resolve.url =
element url {
att.id?,
attribute destdir { text }?,
attribute url { text }?,
attribute destfile { text }?,
empty
}
jlink =
element jlink {
task.att.global,
attribute outfile { text }?,
attribute compress { boolean }?,
att.defaultexcludes?,
att.followsymlinks?,
attribute addfiles { text }?,
att.casesensitive?,
attribute mergefiles { text }?,
att.patterns.group,
(selector.core.group
| patterns.group
| selector.container.group
| custom
| mergefiles
| addfiles)*
}
mergefiles =
element mergefiles {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
addfiles =
element addfiles {
att.id?,
att.location?,
att.refid?,
att.description?,
att.path?,
(fileset
| dirset
| extdirs
| existing
| filelist
| pathelement
| path)*
}
cvstagdiff =
element cvstagdiff {
task.att.global,
attribute cvsrsh { text }?,
attribute endtag { text }?,
attribute quiet { boolean }?,
attribute passfile { text }?,
attribute command { text }?,
attribute package { text }?,
attribute cvsroot { text }?,
attribute reallyquiet { boolean }?,
attribute starttag { text }?,
attribute output { text }?,
attribute port { text }?,
attribute compressionlevel { text }?,
attribute dest { text }?,
attribute destfile { text }?,
attribute enddate { text }?,
attribute noexec { boolean }?,
attribute error { text }?,
attribute failonerror { boolean }?,
attribute append { boolean }?,
attribute date { text }?,
attribute startdate { text }?,
attribute compression { boolean }?,
attribute tag { text }?,
commandline*
}
chmod =
element chmod {
task.att.global,
attribute addsourcefile { boolean }?,
att.excludes?,
attribute verbose { boolean }?,
attribute parallel { boolean }?,
attribute input { text }?,
attribute executable { text }?,
attribute force { boolean }?,
attribute inputstring { text }?,
attribute searchpath { boolean }?,
attribute relative { boolean }?,
attribute skipemptyfilesets { boolean }?,
attribute command { text }?,
attribute forwardslash { boolean }?,
attribute spawn { boolean }?,
att.includes?,
attribute vmlauncher { boolean }?,
att.file?,
attribute logerror { boolean }?,
attribute errorproperty { text }?,
attribute failonerror { boolean }?,
attribute output { text }?,
attribute error { text }?,
att.defaultexcludes?,
attribute os { text }?,
attribute dest { text }?,
attribute resolveexecutable { boolean }?,
attribute resultproperty { text }?,
attribute ignoremissing { boolean }?,
attribute failifexecutionfails { boolean }?,
attribute append { boolean }?,
attribute timeout { text }?,
attribute maxparallel { text }?,
attribute outputproperty { text }?,
attribute perm { text }?,
att.dir?,
attribute newenvironment { boolean }?,
attribute type { "file" | "dir" | "both" }?,
(mapper
| \include
| srcfile
| exclude
| targetfile
| patternset
| redirector
| env
| filelist
| fileset
| dirset
| arg)*
}
jarlib-manifest =
element jarlib-manifest {
task.att.global,
attribute destfile { text }?,
(options | \attribute | depends | extension)*
}
options =
element options {
att.id?,
att.refid?,
att.description?,
(fileset | libfileset | extension)*
}
sound =
element sound {
task.att.global,
(fail | success)*
}
success =
element success {
att.id?,
attribute loops { text }?,
attribute source { text }?,
attribute duration { text }?,
empty
}
scriptdef =
element scriptdef {
task.att.global,
attribute src { text }?,
att.name?,
attribute uri { text }?,
attribute classpath { text }?,
attribute language { text }?,
attribute classpathref { idref.type }?,
attribute loaderref { idref.type }?,
attribute reverseloader { boolean }?,
(text | classpath | \element | \attribute)*
}
defaultexcludes =
element defaultexcludes {
task.att.global,
attribute remove { text }?,
attribute echo { boolean }?,
attribute default { boolean }?,
attribute add { text }?,
empty
}
mparse =
element mparse {
task.att.global,
attribute cleanup { boolean }?,
attribute verbose { boolean }?,
attribute maxmemory { text }?,
attribute metamatahome { text }?,
attribute target { text }?,
attribute debugparser { boolean }?,
attribute home { text }?,
attribute debugscanner { boolean }?,
(fileset | jvmarg | classpath | sourcepath)*
}
include "core.rnc"
include "optional.rnc"
# Any
anyElement =
element * {
(attribute * { text }
| text
| anyElement)*
}
