import java.util.Properties;

import java.util.Stack;

    /**

     * Set a new inherited user property, which cannot be overwritten 

     * by set/unset property calls. If a user property with the

     * same name is already present the value is not overridden.

     * Also marks this property as a property that has not come 

     * from the command line.

     * 

     * @param ns The namespace for the property (currently not used).

     * @param n Name of property

     * @param v Value to set

     */

    public synchronized void setNewInheritedProperty(String ns, 

            String n, String v) {

        if (getUserProperty(null, n) == null) {

            setInheritedProperty(null, n, v);

        } else {

            project.log("Override ignored for " + n, Project.MSG_VERBOSE);

        }

    }

    /**

     * Adds a set of unexpanded properties.

     * <p>The properties are resolved, prefixed, expanded and added with 

     * {@link #setNewProperty(String, String, Object)}.</p>

     * @param props The unexpanded properties.

     * @param prefix The prefix to add to each property name

     *               after properties resolved.

     *               <code>null</code> if no prefix.

     */

    public synchronized void addNewProperties(String ns

            , Properties props, String prefix) {

        addUnexpandedProperties(ns, props, prefix, false);

    }

    /**

     * Adds a set of unexpanded inherited user properties.

     * <p>The properties are resolved, prefixed, expanded and added with 

     * {@link #setNewInheritedProperty(String, String, String)}.</p>

     * @param props The unexpanded inherited user properties.

     * @param prefix The prefix to add to each property name

     *               after properties resolved.

     *               <code>null</code> if no prefix.

     */

    public synchronized void addNewInheritedProperties(String ns

            , Properties props, String prefix) {

        addUnexpandedProperties(ns, props, prefix, true);

    }

    /**

     * Iterate through a set of properties,

     * resolve them then assign them

     * @param props The properties to iterate over.

     * @param prefix The prefix to add to each name.

     * @param userProperties Whether to be added as user properties.

     */

    private void addUnexpandedProperties(String ns

            , Properties props, String prefix, boolean userProperties) {

        resolveAllProperties(props);

        Enumeration e = props.keys();

        while (e.hasMoreElements()) {

            String propertyName = (String) e.nextElement();

            String propertyValue = props.getProperty(propertyName);

            String v = replaceProperties(null, propertyValue, null);

            if (prefix != null) {

                propertyName = prefix + propertyName;

            }

            if (userProperties) {

                setNewInheritedProperty(null, propertyName, v);

            } else {

                setNewProperty(null, propertyName, v);

            }

        }

    }

    /**

     * Resolve properties inside a properties hashtable

     * @param props Properties object to resolve

     */

    private void resolveAllProperties(Properties props) throws BuildException {

        for (Enumeration e = props.keys(); e.hasMoreElements();) {

            String propertyName = (String) e.nextElement();

            Stack referencesSeen = new Stack();

            resolve(props, propertyName, referencesSeen);

        }

    }

    /**

     * Recursively expand the named property using the project's

     * reference table and the given set of properties - fail if a

     * circular definition is detected.

     *

     * @param props Properties object to resolve

     * @param name Name of the property to resolve

     * @param referencesSeen Stack of all property names that have

     *                       been tried to expand before coming here.

     */

    private void resolve(Properties props, String name, Stack referencesSeen)

        throws BuildException {

        if (referencesSeen.contains(name)) {

            throw new BuildException("Property " + name + " was circularly "

                                     + "defined.");

        }

        String propertyValue = props.getProperty(name);

        Vector fragments = new Vector();

        Vector propertyRefs = new Vector();

        parsePropertyString(propertyValue, fragments, propertyRefs);

        if (propertyRefs.size() != 0) {

            referencesSeen.push(name);

            StringBuffer sb = new StringBuffer();

            Enumeration i = fragments.elements();

            Enumeration j = propertyRefs.elements();

            while (i.hasMoreElements()) {

                String fragment = (String) i.nextElement();

                if (fragment == null) {

                    String propertyName = (String) j.nextElement();

                    Object o = getProperty(null, propertyName);

                    fragment = (o == null) ? null : o.toString();

                    if (fragment == null) {

                        if (props.containsKey(propertyName)) {

                            resolve(props, propertyName, referencesSeen);

                            fragment = props.getProperty(propertyName);

                        } else {

                            fragment = "${" + propertyName + "}";

                        }

                    }

                }

                sb.append(fragment);

            }

            propertyValue = sb.toString();

            props.put(name, propertyValue);

            referencesSeen.pop();

        }

    }

        PropertyHelper ph = PropertyHelper.getPropertyHelper(getProject());