ant-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Dominique Devienne <ddevie...@gmail.com>
Subject Re: idiom to pass ant command line args to java task?
Date Fri, 02 Dec 2005 15:01:21 GMT
> $0 refers to the first argument. Where is the end? Is $9 the last
> accessible argument or $10...? Then using that reference must be followed by
> a split character.
>    ant -- one two .... eleven
>    <echo>$10HelloWorld</echo>
>    a)  two0HelloWorld
>    b)  elevenHelloWorld

Did you apply the patch? AFAIK, only ${NAME} expand references in ANT,
so <echo>$10HelloWorld</echo> should output exactly that, $10HelloWorld.

You'd need to write ${$10}HelloWorld if your intent is to re-reference the var.

> Printing out multiple arguments with $* seems to ignore $0.
>    C:\oss\org_apache\ant16>build start -- toto titi tutu
>    $* = titi tutu
> Where is "toto"?
> (not tested, just the docu in the bug-report)

toto is in $0.

The rational is to be able to have a generic 'start' or 'run' target,
which takes
not only arguments, but also a program name. Here's my canonical use case:

  <!-- ====================================================
       Runs arbitrary Java class (demo, example, benchmark)
    -->
  <target name="start" depends="init"
          description="Runs arbitrary Java class (demo, example, benchmark)">

    <fail unless="$0">Usage: build start -- &lt;javaclass&gt; [args]</fail>

    <java classname="${$0}" fork="yes"> ...
      <arg line="${$*}" />
    </java>

  </target>

Since Ant lacks functionality to manipulate sequences (like a .sh
shift, or XSL sequence processing using XPath functions), having the
"first" argument into a special $0 property enables this use, and
people who want all the arguments can simlpy do ${$0} ${$*}.

Put simply, it's to be able to use Ant as a mini program launcher.

> The sign: $
> Because it is a property the $ seems to be ok to me. Using with out
> the curly brackets {} shows the special meaning and avoids conflicts
> with existing properties.   $1 != ${1}

Like I said, I didn't know Ant supported not using the curly braces...

> The number of arguments: $#
> Ok with me. ... ok, I often write perl ...

I don't use it, but thought I'd add it for completeness, and to be
consistent with other languages that also set it.

> The array: $*
> Should be a list which can easily be iterated by <ac:for>.
> I would prefer a comma separated list
> - easier for <ac:for> as the comma is its default separator
> - usually you (ok me) show a list separated by comma

All the special properties set, whose name start with $, are just
that, properties, i.e. plain strings. $* is designed to be use in <arg
line="${$*}" /> as the use case above shows, so it cannot be comma
separated.

I'm not too sure whether use with <ac:for> makes sense. I guess I
could also create a java.util.List<String> of all the arguments, and
put that in a reference called $*, then adding support for <ac:for>,
but I don't see a use for it personally.

> The dividing argument: --
> The '-' is a valid sign for target names, so '--' would be a valid target.
> But because a starting '-' is responsible for passing arguments to Ant, targets
> with a leading '-' cant be started from commandline. Which is there since .... a long
time.
> And we dont have a '--' argument yet.
> Ok with me.

The -- "marker" argument is something usual in many Unix commands.
Usually means that the command should look no further for its
arguments, but the way I defined it is more in line with a program on
Solaris/CDE I was using a few years ago, that was used to start the
X11 server. Args before the -- were args to the X11-launching program,
while everything after the -- were (additional) args for X11 itself.
It's similar here, where everything before the (optional) -- is an
argument to Ant itself, while after the -- its an argument to
something else (a command, usually a <java> or <exec> task, started by
a given target).

> Additional task: <cliargs/>
> As this thread showed, we need to pass the parameters directly to <java> task (or
<exec>...).
> So converting the $* parameter list to couple of <arg/> tags should be easy.
> The easiest would be a
>    <arg line="$*"/>
> but with additional information this would become difficult.
>    <arg value="-opt $0"/>
>    <arg value="-opt $1"/>
>    ...
> So my idea is something like
>    <java|exec>
>        <cliargs format="-opt *"/>
>    </java|exec>
> which will be same with an "ant -- one two" as
>    <java|exec>
>        <arg value="-opt one"/>
>        <arg value="-opt two"/>
>    </java|exec>
> Makes sence or too special?

I think the use case is already supported, by leveraging <arg
line="${$*}" /> and using simple strings.

Does it make more sense? --DD

---------------------------------------------------------------------
To unsubscribe, e-mail: user-unsubscribe@ant.apache.org
For additional commands, e-mail: user-help@ant.apache.org


Mime
View raw message