Attachment 22426 Details for Bug 45612 – svn diff with http://svn.apache.org/repos/asf/ant/core/trunk @ 684142

[patch] svn diff with http://svn.apache.org/repos/asf/ant/core/trunk @ 684142

added-sim-and-addressing.diffs (text/plain), 27.46 KB, created by Oran Fry on 2008-08-11 02:03:17 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Oran Fry

Created: 2008-08-11 02:03:17 UTC

Size: 27.46 KB

patch

obsolete

>Index: src/main/org/apache/tools/ant/DefaultLogger.java
>===================================================================
>--- src/main/org/apache/tools/ant/DefaultLogger.java	(revision 684142)
>+++ src/main/org/apache/tools/ant/DefaultLogger.java	(working copy)
>@@ -42,6 +42,12 @@
>      */
>     public static final int LEFT_COLUMN_SIZE = 12;
> 
>+    /**
>+     * Tab sequence for indenting output where needed
>+     * Currently four spaces
>+     */
>+    public static final String TAB_SEQUENCE = "|   ";
>+
>     // CheckStyle:VisibilityModifier OFF - bc
>     /** PrintStream to write non-error messages to */
>     protected PrintStream out;
>@@ -208,6 +214,22 @@
>             && !event.getTarget().getName().equals("")) {
>             String msg = StringUtils.LINE_SEP
>                 + event.getTarget().getName() + ":";
>+
>+            //if addressing is on, tab it in
>+            if ( event.getProject().getAddressingOn() ) {
>+                StringBuffer tmp = new StringBuffer();
>+                ProjectAddress address = event.getProject().getAddress();
>+                if ( address != null ) {
>+                    for ( int i=0; i<address.noChambers(); i++ ) {
>+                        tmp.append(TAB_SEQUENCE);
>+                    }
>+                    msg = tmp.toString() + StringUtils.LINE_SEP;
>+                    msg += tmp.toString() + address +
>+                        " " + event.getTarget().getName() + ":";
>+                }
>+
>+            }
>+
>             printMessage(msg, out, event.getPriority());
>             log(msg);
>         }
>@@ -260,9 +282,30 @@
>                 for (int i = 0; i < size; i++) {
>                     tmp.append(" ");
>                 }
>+
>+                //if addressing is on, tab it in even more
>+                StringBuffer tabs = new StringBuffer();
>+                if ( event.getProject().getAddressingOn() ) {
>+                    ProjectAddress address = event.getProject().getAddress();
>+                    if ( address != null ) {
>+                        for ( int i=0; i<address.noChambers(); i++ ) {
>+                            tabs.append(TAB_SEQUENCE);
>+                        }
>+                    }
>+                    tabs.append(TAB_SEQUENCE);
>+                    tmp = new StringBuffer( tabs.toString() + tmp.toString() );
>+                }
>+
>                 tmp.append(label);
>                 label = tmp.toString();
> 
>+                //if simulation mode is on, use a customized label
>+                if ( event.getProject().isSimulationMode() ) {
>+                    if ( name.equals("ant") ) {
>+                        label = tabs.toString();
>+                    }
>+                }
>+
>                 BufferedReader r = null;
>                 try {
>                     r = new BufferedReader(
>Index: src/main/org/apache/tools/ant/Task.java
>===================================================================
>--- src/main/org/apache/tools/ant/Task.java	(revision 684142)
>+++ src/main/org/apache/tools/ant/Task.java	(working copy)
>@@ -340,6 +340,19 @@
>      * is still fired, but with the exception as the cause.
>      */
>     public final void perform() {
>+
>+        //if in sim mode, dont execute tasks except antcall, ant and import
>+        if ( getProject().isSimulationMode() ) {
>+            boolean shouldExecute =
>+                getTaskName().equals("antcall") ||
>+                getTaskName().equals("ant") ||
>+                getTaskName().equals("import");
>+
>+            if ( !shouldExecute ) {
>+                return;
>+            }
>+        }
>+
>         if (!invalid) {
>             getProject().fireTaskStarted(this);
>             Throwable reason = null;
>Index: src/main/org/apache/tools/ant/Project.java
>===================================================================
>--- src/main/org/apache/tools/ant/Project.java	(revision 684142)
>+++ src/main/org/apache/tools/ant/Project.java	(working copy)
>@@ -210,6 +210,22 @@
>     private boolean keepGoingMode = false;
> 
>     /**
>+     * Simulation mode
>+     */
>+    private boolean simulationMode;
>+
>+    /**
>+     * Addressing options
>+     */
>+    private boolean addressingOn = false;
>+    private ProjectAddress address = null;
>+    private int nextSubAddress = 1;
>+    private ProjectAddress addressingFrom = null;
>+    private ProjectAddress addressingTo = null;
>+    private ProjectAddress addressingDescend = null;
>+
>+
>+    /**
>      * Set the input handler.
>      *
>      * @param handler the InputHandler instance to use for gathering input.
>@@ -867,6 +883,117 @@
>     }
> 
>     /**
>+     * Set simulation mode. In this mode Ant will only execute the
>+     * tasks involved in traversing the target tree, and skip the rest
>+     * Namely, these tasks are &lt;ant&gt;, &lt;antcall&gt; and &lt;import&gt;
>+     * @param simulationMode true to turn on simulation mode, false to turn it off
>+     */
>+    public void setSimulationMode(boolean simulationMode) {
>+        this.simulationMode = simulationMode;
>+    }
>+
>+    /**
>+     * Return the simulation mode.
>+     * @return true if simulation mode is on, false otherwise
>+     */
>+    public boolean isSimulationMode() {
>+        return simulationMode;
>+    }
>+
>+    /**
>+     * Set Addressing on or off.
>+     * When addressing is on, each project will be assigned an address
>+     * which will be displayed in front its targets' names as they are executed.
>+     * These addresses can be used to select subsets of subprojects to run
>+     * using the -from, -to and -descend arguments
>+     * @param addressingMode true to turn addressing on, false to turn it off
>+     */
>+    public void setAddressingOn( boolean addressingOn ) {
>+        this.addressingOn = addressingOn;
>+    }
>+
>+    /**
>+     * Get the addressingMode for this project
>+     * @return true if Addressing is on, false otherwise
>+     */
>+    public boolean getAddressingOn() {
>+        return addressingOn;
>+    }
>+
>+    /**
>+    * Sets the address of this project.
>+    * @param address The address of this project
>+    */
>+    public void setAddress( ProjectAddress address ) {
>+        this.address = address;
>+    }
>+    
>+    /**
>+    * Returns the address of this project.
>+    * @return the address of this project
>+    */
>+    public ProjectAddress getAddress() {
>+        return address;
>+    }
>+    
>+    /**
>+     * Get the next sub address and increment
>+     * Used when creating an address for a subproject
>+     * @return the next sub address of this project
>+     */
>+    public int getNextSubAddress() {
>+        return nextSubAddress++;
>+    }
>+
>+    /**
>+     * Set the target to execute from by its address
>+     * @param from the address of the target to execute from
>+     */
>+    public void setAddressingFrom( ProjectAddress addressingFrom ) {
>+        this.addressingFrom = addressingFrom;
>+    }
>+
>+    /**
>+     * Get the address of the target to execute from
>+     * @return the address of the target to execute from
>+     */
>+    public ProjectAddress getAddressingFrom() {
>+        return addressingFrom;
>+    }
>+
>+    /**
>+     * Set the target to execute to by its address
>+     * @param from the address of the target to execute to
>+     */
>+    public void setAddressingTo( ProjectAddress addressingTo ) {
>+        this.addressingTo = addressingTo;
>+    }
>+
>+    /**
>+     * Get the address of the target to execute to
>+     * @return the address of the target to execute to
>+     */
>+    public ProjectAddress getAddressingTo() {
>+        return addressingTo;
>+    }
>+
>+    /**
>+     * Set the target to descend by its address
>+     * @param from the address of the target to descend
>+     */
>+    public void setAddressingDescend( ProjectAddress addressingDescend ) {
>+        this.addressingDescend = addressingDescend;
>+    }
>+
>+    /**
>+     * Get the address of the target to descend
>+     * @return the address of the target to descend
>+     */
>+    public ProjectAddress getAddressingDescend() {
>+        return addressingDescend;
>+    }
>+
>+    /**
>      * Return the version of Java this class is running under.
>      * @return the version of Java as a String, e.g. "1.1" .
>      * @see org.apache.tools.ant.util.JavaEnvUtils#getJavaVersion
>Index: src/main/org/apache/tools/ant/ProjectAddress.java
>===================================================================
>--- src/main/org/apache/tools/ant/ProjectAddress.java	(revision 0)
>+++ src/main/org/apache/tools/ant/ProjectAddress.java	(revision 0)
>@@ -0,0 +1,323 @@
>+/*
>+ *  Licensed to the Apache Software Foundation (ASF) under one or more
>+ *  contributor license agreements.  See the NOTICE file distributed with
>+ *  this work for additional information regarding copyright ownership.
>+ *  The ASF licenses this file to You 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.
>+ *
>+ */
>+package org.apache.tools.ant;
>+
>+/*
>+ * A class representing a project address
>+ * The main (root) project has a null address
>+ * Subprojects are created with &lt;ant&gt; and &lt;antcall&gt;
>+ * The subprojects of the main project have the addresses 1, 2, 3 etc.
>+ * Subprojects of project 1 have the addresses 1.1, 1.2, 1.3 etc.
>+ * Subprojects of project 2 have the addresses 2.1, 2.2, 2.3 etc.
>+ * And so on
>+ * Address "root" can be used to point to the root project
>+ * Address "infinity" points to a non-existent first level subproject with an
>+ * infinitly high address. If there are n subprojects in the main project,
>+ * the address "infinity" acts the same as address n+1)
>+ * Can be converted to a string representation and back
>+ * Objects of this class are immutable
>+ *
>+ */
>+public class ProjectAddress {
>+    
>+    private boolean isRoot = false;
>+    private boolean isInfinity = false;
>+    private int[] chambers = null;
>+    private int noChambers = -1;
>+    
>+    public static void main( String[] args ) {
>+        if ( args.length < 2 ) {
>+            System.err.println("Please specify two target addresses");
>+            return;
>+        }
>+
>+        ProjectAddress a, b;
>+        try {
>+            a = new ProjectAddress(args[0]);
>+            b = new ProjectAddress(args[1]);
>+        } catch ( BuildException be ) {
>+            System.err.println("Failed to construct address");
>+            System.err.println(be.getMessage());
>+            return;
>+        }
>+        System.out.println( "a: " + a );
>+        System.out.println( "b: " + b );
>+        System.out.println( "a.isAfter(b): " + a.isAfter(b) );
>+        System.out.println( "b.isAfter(a): " + b.isAfter(a) );
>+        System.out.println( "a.isDescendantOf(b): " + a.isDescendantOf(b) );
>+        System.out.println( "b.isDescendantOf(a): " + b.isDescendantOf(a) );
>+
>+    }
>+
>+    /**
>+     * Construct a ProjectAddress from its string representation
>+     * @param addressAsString a string representation of an address
>+     */
>+    public ProjectAddress( String addressAsString ) throws BuildException {
>+
>+        //catch null
>+        if ( addressAsString == null ) {
>+            throw new BuildException( "null address string" );
>+        }
>+
>+        //catch root keyword
>+        if ( addressAsString.equals("root") ) {
>+            isRoot = true;
>+            return;
>+        }
>+
>+        //catch infinity keyword
>+        if ( addressAsString.equals("infinity") ) {
>+            isInfinity = true;
>+            return;
>+        }
>+
>+        //spilt string address into chambers
>+        String[] chambersAsStrings = addressAsString.split("\\.");
>+
>+        //create empty chambers for this address
>+        noChambers = chambersAsStrings.length;
>+        chambers = new int[noChambers];
>+        
>+        //load the chambers, checking each is a positive integer
>+        for ( int i=0; i<chambersAsStrings.length; i++ ) {
>+
>+            //check it's an int
>+            try {
>+                chambers[i] = Integer.parseInt( chambersAsStrings[i] );
>+            } catch( NumberFormatException e ) {
>+                throw new BuildException( "invalid address string (contains non int chambers): '" + addressAsString + "'" );
>+            }
>+
>+            //check it's not negative
>+            if ( chambers[i] < 0 ) {
>+                throw new BuildException( "invalid address string (contains negative int chambers): '" + addressAsString +  "'" );
>+            }
>+
>+        }
>+
>+    }
>+
>+    /**
>+     * Create a ProjectAddress as the child of the given parent ProjectAddress
>+     * using the given subaddress
>+     * E.g., passing in parent 3.5 and subaddress 2 will construct address 3.5.2
>+     */
>+    public ProjectAddress( ProjectAddress parent, int subAddress ) throws BuildException {
>+
>+        if ( subAddress < 0 ) {
>+            throw new BuildException( "subaddress must be positive" );
>+        }
>+
>+        if ( parent == null || parent.isRoot() ) {
>+
>+            //create one chamber
>+            noChambers = 1;
>+            chambers = new int[noChambers];
>+            chambers[0] = subAddress;
>+
>+        } else {
>+
>+            //create empty chambers with one more chamber than parent
>+            noChambers = parent.noChambers()+1;
>+            chambers = new int[noChambers];
>+
>+            //copy parent chambers to this address
>+            for ( int i=0; i<parent.noChambers(); i++ ) {
>+                chambers[i] = parent.getChamber(i);
>+            }
>+
>+            //the last chamber is the sub address
>+            chambers[noChambers-1] = subAddress;
>+
>+        }
>+
>+    }
>+
>+    /**
>+     * @return true if this address is the root, false otherwise
>+     */
>+    public boolean isRoot() {
>+        return isRoot;
>+    }
>+
>+    /**
>+     * @return true if this address is the infinity address, false otherwise
>+     */
>+    public boolean isInfinity() {
>+        return isInfinity;
>+    }
>+
>+    /**
>+     * Gets the value in the given chamber of this address
>+     * E.g., getChamber(2) on address 3.4.7.5 will return 7
>+     * @return the value in the given chamber
>+     */
>+    public int getChamber( int chamber ) {
>+        if ( chamber >=0 && chamber < noChambers ) {
>+            return chambers[chamber];
>+        } else {
>+            return -1;
>+        }
>+    }
>+
>+    /**
>+     * @return the number of chambers this address has
>+     */
>+    public int noChambers() {
>+        return noChambers;
>+    }
>+
>+    /**
>+     * Converts this address to its string representation
>+     * That is, either "root", "infinity", or a string like:
>+     * "1.11.2.6"
>+     * @return the string representation of this address
>+     */
>+    public String toString() {
>+        if ( isRoot ) {
>+            return "root";
>+        }
>+
>+        if ( isInfinity ) {
>+            return "infinity";
>+        }
>+
>+        StringBuffer addressString = new StringBuffer();
>+        for ( int i=0; i<noChambers; i++ ) {
>+            addressString.append( "" + chambers[i] );
>+            if ( i < noChambers -1 ) {
>+                addressString.append( "." );
>+            }
>+        }
>+        return addressString.toString();
>+
>+    }
>+
>+    /*
>+     * Returns true if this address is after the given address
>+     * E.g., new ProjectAddress("1.6").isAfter(new ProjectAddress("1.5")) would return true
>+     * E.g., new ProjectAddress("1.4").isAfter(new ProjectAddress("1.8.5)) would return false
>+     * By convention, consider an address to be after itself
>+     * Have used 'this' keyword in code for readablilty
>+     */
>+    public boolean isAfter( ProjectAddress otherAddress ) throws BuildException {
>+
>+        //catch null
>+        if ( otherAddress == null ) {
>+            throw new BuildException(
>+                "Null ProjectAddress given in ProjectAddress.isAfter()");
>+        }
>+
>+        //everything is after root
>+        if ( otherAddress.isRoot() ) {
>+            return true;
>+        }
>+
>+        //root is after nothing
>+        //(except itself, but that's already caught)
>+        if ( this.isRoot ) {
>+            return false;
>+        }
>+
>+        //infinity is after everything
>+        if ( this.isInfinity ) {
>+            return true;
>+        }
>+
>+        //nothing is after infinity
>+        // (except itself, but that's already caught)
>+        if ( otherAddress.isInfinity() ) {
>+            return false;
>+        }
>+
>+        //step through, checking that chambers of this are higher than
>+        //or equal to chambers of otherAddress
>+        for ( int i=0; i<otherAddress.noChambers(); i++ ) {
>+            
>+            int thisChamber = i < this.noChambers ? this.chambers[i] : 0;
>+
>+            if(  thisChamber < otherAddress.getChamber(i) ) {
>+                return false;
>+            }
>+
>+            if(  thisChamber > otherAddress.getChamber(i) ) {
>+                return true;
>+            }
>+        }
>+
>+        //first [otherAddress.noChambers()] chambers are equal
>+        return true;
>+    }
>+
>+
>+    public boolean isDescendantOf( ProjectAddress otherAddress ) {
>+
>+        //catch null
>+        if ( otherAddress == null ) {
>+            throw new BuildException(
>+                "Null ProjectAddress given in ProjectAddress.isDescendantOf()");
>+        }
>+
>+        //everything decends from root
>+        if ( otherAddress.isRoot() ) {
>+            return true;
>+        }
>+
>+        //root descends from nothing
>+        //(except itself but that's already caught)
>+        if ( this.isRoot ) {
>+            return false;
>+        }
>+
>+        //infinity descends from itself
>+        if ( this.isInfinity && otherAddress.isInfinity() ) {
>+            return true;
>+        }
>+
>+        //nothing descends from infinity
>+        //(except itself but that's already caught)
>+        if ( otherAddress.isInfinity() ) {
>+            return false;
>+        }
>+
>+        //infinity descends only from nothing
>+        //(except root and itself, but that's already caught)
>+        if ( this.isInfinity ) {
>+            return false;
>+        }
>+
>+        //make sure x is at least as deep as y
>+        if ( this.noChambers < otherAddress.noChambers() ) {
>+            return false;
>+        }
>+
>+        //step through, making sure x values are equal to y values
>+        for ( int i=0; i<otherAddress.noChambers(); i++ ) {
>+            if(  this.chambers[i] != otherAddress.getChamber(i) ) {
>+                return false;
>+            }
>+        }
>+
>+        //first [otherAddress.noChambers()] chambers are equal
>+        return true;
>+
>+    }
>+
>+
>+}
>Index: src/main/org/apache/tools/ant/taskdefs/Ant.java
>===================================================================
>--- src/main/org/apache/tools/ant/taskdefs/Ant.java	(revision 684142)
>+++ src/main/org/apache/tools/ant/taskdefs/Ant.java	(working copy)
>@@ -41,6 +41,8 @@
> import org.apache.tools.ant.Main;
> import org.apache.tools.ant.types.PropertySet;
> import org.apache.tools.ant.util.FileUtils;
>+import org.apache.tools.ant.util.StringUtils;
>+import org.apache.tools.ant.ProjectAddress;
> 
> /**
>  * Build a sub-project.
>@@ -103,6 +105,9 @@
>     /** the targets to call on the new project */
>     private Vector targets = new Vector();
> 
>+    /** address to give to the new project */
>+    private ProjectAddress address = null;
>+
>     /** whether the target attribute was specified **/
>     private boolean targetAttributeSet = false;
> 
>@@ -191,6 +196,16 @@
>     private void initializeProject() {
>         newProject.setInputHandler(getProject().getInputHandler());
> 
>+        newProject.setSimulationMode(getProject().isSimulationMode());
>+
>+        if ( getProject().getAddressingOn() ) {
>+            newProject.setAddressingOn(true);
>+            newProject.setAddress(address);
>+            newProject.setAddressingFrom(getProject().getAddressingFrom());
>+            newProject.setAddressingTo(getProject().getAddressingTo());
>+            newProject.setAddressingDescend(getProject().getAddressingDescend());
>+        }
>+
>         Iterator iter = getBuildListeners();
>         while (iter.hasNext()) {
>             newProject.addBuildListener((BuildListener) iter.next());
>@@ -327,6 +342,64 @@
>      * probably also if a BuildException is thrown by the new project.
>      */
>     public void execute() throws BuildException {
>+
>+        //if addressing is on, check if we really want to excecute the subproject
>+        if ( getProject().getAddressingOn() ) {
>+
>+            //figure out what the address of the target should be
>+            ProjectAddress callingAddress = getProject().getAddress();
>+            int subAddress = getProject().getNextSubAddress();
>+            address = new ProjectAddress( callingAddress, subAddress );
>+           
>+            boolean shouldExecuteOnFrom =
>+                getProject().getAddressingFrom() == null ||
>+                getProject().getAddressingFrom().isDescendantOf(address) ||
>+                address.isAfter(getProject().getAddressingFrom());
>+            if ( !shouldExecuteOnFrom ) {
>+                return;
>+            }
>+
>+            boolean shouldExecuteOnDescend =
>+                getProject().getAddressingDescend() == null ||
>+                getProject().getAddressingDescend().isDescendantOf(address) ||
>+                address.isDescendantOf(getProject().getAddressingDescend());
>+            if ( !shouldExecuteOnDescend ) {
>+                return;
>+            }
>+
>+            boolean shouldExecuteOnTo =
>+                getProject().getAddressingTo() == null ||
>+                !address.isAfter(getProject().getAddressingTo());
>+            if ( !shouldExecuteOnTo ) {
>+                return;
>+            }
>+        }
>+
>+        //if in simulation mode, only execute antcalls
>+        if ( getProject().isSimulationMode() ) {
>+            if ( !getTaskName().equals("antcall") ) {
>+                StringBuffer msg = new StringBuffer(StringUtils.LINE_SEP);
>+                if ( address != null ) {
>+                    msg.append( address.toString() + " -> " );
>+                }
>+                if ( targets != null && targets.size() > 0 ) {
>+                    for ( int i=0; i<targets.size(); i++ ) {
>+                        msg.append( targets.get(i) );
>+                        if ( i<targets.size()-1 ) {
>+                            msg.append( "," );
>+                        }
>+                    }
>+                     msg.append( " " );
>+                }
>+                if ( antFile != null ) {
>+                    msg.append( "in " + antFile );
>+                }
>+
>+                log( msg.toString() );
>+                return;
>+            }
>+        }
>+
>         File savedDir = dir;
>         String savedAntFile = antFile;
>         Vector locals = new Vector(targets);
>Index: src/main/org/apache/tools/ant/Main.java
>===================================================================
>--- src/main/org/apache/tools/ant/Main.java	(revision 684142)
>+++ src/main/org/apache/tools/ant/Main.java	(working copy)
>@@ -143,6 +143,19 @@
>     private Integer threadPriority = null;
> 
>     /**
>+     * simulation mode
>+     */
>+    private boolean simulationMode = false;
>+
>+    /**
>+     * addressing options
>+     */
>+    private boolean addressingOn = false;
>+    private ProjectAddress addressingFrom = null;
>+    private ProjectAddress addressingTo = null;
>+    private ProjectAddress addressingDescend = null;
>+
>+    /**
>      * proxy flag: default is false
>      */
>     private boolean proxy = false;
>@@ -372,6 +385,16 @@
>                 keepGoingMode = true;
>             } else if (arg.equals("-nice")) {
>                 i = handleArgNice(args, i);
>+            } else if (arg.equals("-sim")) {
>+                i = handleArgSim(args, i);
>+            } else if (arg.equals("-addressing")) {
>+                i = handleArgAddressing(args, i);
>+            } else if (arg.equals("-from")) {
>+                i = handleArgFromToDescend(args, i);
>+            } else if (arg.equals("-to")) {
>+                i = handleArgFromToDescend(args, i);
>+            } else if (arg.equals("-descend")) {
>+                i = handleArgFromToDescend(args, i);
>             } else if (LAUNCH_COMMANDS.contains(arg)) {
>                 //catch script/ant mismatch with a meaningful message
>                 //we could ignore it, but there are likely to be other
>@@ -562,6 +585,47 @@
>         return pos;
>     }
> 
>+    /** Handle the -sim argument. */
>+    private int handleArgSim(String[] args, int pos) {
>+        simulationMode = true;
>+        return pos;
>+    }
>+
>+    /** Handle the -addressing argument. */
>+    private int handleArgAddressing(String[] args, int pos) {
>+        addressingOn = true;
>+        return pos;
>+    }
>+
>+    /** Handle the -from -to or -descend argument. */
>+    private int handleArgFromToDescend(String[] args, int pos) {
>+
>+        ProjectAddress address;
>+        try {
>+            //this will throw its own BuildException
>+            //if the address in invalid
>+	        address = new ProjectAddress( args[++pos] );
>+        } catch (ArrayIndexOutOfBoundsException aioobe) {
>+            throw new BuildException(
>+                "You must specify an address when using the " +
>+                args[pos-1] + " argument");
>+        }
>+
>+        if ( args[pos-1].equals( "-from" ) ) {
>+            addressingFrom = address;
>+        } else if ( args[pos-1].equals( "-to" ) ) {
>+            addressingTo = address;
>+        } else if ( args[pos-1].equals( "-descend" ) ) {
>+            addressingDescend = address;
>+        } else {
>+            //should never get here
>+            throw new BuildException(
>+                "Unrecognised addressing option: " + args[pos-1] );
>+        }
>+        addressingOn = true;
>+        return pos;
>+    }
>+
>     // --------------------------------------------------------
>     //    other methods
>     // --------------------------------------------------------
>@@ -738,6 +802,22 @@
>                                         buildFile.getAbsolutePath());
> 
>                 project.setKeepGoingMode(keepGoingMode);
>+
>+                project.setSimulationMode( simulationMode );
>+
>+                //a special addressing situation, -to root
>+                if ( addressingOn && addressingTo != null && addressingTo.isRoot() ) {
>+                    return;
>+                }
>+
>+                //addressing options
>+                if ( addressingOn ) {
>+                    project.setAddressingOn(true);
>+                    project.setAddressingFrom(addressingFrom);
>+                    project.setAddressingTo(addressingTo);
>+                    project.setAddressingDescend(addressingDescend);
>+                }
>+
>                 if (proxy) {
>                     //proxy setup if enabled
>                     ProxySetup proxySetup = new ProxySetup(project);
>@@ -910,7 +990,14 @@
>         msg.append("  -noclasspath           Run ant without using CLASSPATH" + lSep);
>         msg.append("  -autoproxy             Java1.5+: use the OS proxy settings"
>                 + lSep);
>-        msg.append("  -main <class>          override Ant's normal entry point");
>+        msg.append("  -main <class>          override Ant's normal entry point" + lSep);
>+        msg.append("  -sim                   simulation - show targets that would be executed" + lSep
>+                 + "                           but don't actually do anything" + lSep );
>+        msg.append("  -addressing            turn on subproject addressing" + lSep);
>+        msg.append("  -from <address>        execute from subproject with <address>" + lSep);
>+        msg.append("  -to <address>          execute up to subproject with <address>" + lSep);
>+        msg.append("  -descend <address>     execute only subproject with <address>");
>+
>         System.out.println(msg.toString());
>     }
>

Actions: View | Diff

Attachments on bug 45612: 22426