if (mArgumentOnly.matches())        {            result = new HashSet(evaluateArgument(argStack, name));        }        else        {            result = new HashSet();            boolean loop = true;                    String expr = expression;                    Matcher mOpenBrace    = pOpenBrace.matcher(expression);            Matcher mArgument     = pArgument.matcher(expression);            Matcher mOperator     = pOperator.matcher(expression);            Matcher mSpace        = pSpace.matcher(expression);            while (loop)            {                if (mOpenBrace.find(startPos) && mOpenBrace.start() == startPos)                 {                    startPos = handleBraces(argStack, name, formula, mOpenBrace, position, startPos);                }                else if (mArgument.find(startPos) && mArgument.start() == startPos)                {                    formula.add(mArgument.group(1));                    startPos = mArgument.end();                }                else if (! formula.isEmpty() || (mSpace.find(startPos) && mSpace.start() != startPos))                {                    throw new ParserException("There is something strange near position "                                                + (position + startPos) + " in <" + expression + ">");                }                            if (mOperator.find(startPos) && mOperator.start() == startPos)                {                    formula.add(mOperator.group(1));                    startPos = mOperator.end();                }                else if (mSpace.find(startPos) && mSpace.start() == startPos)                {                    loop = false;                }                else                {                    throw new ParserException("There is something strange near position "                                                 + (position + startPos) + " in <" + expression + ">");                }            }                    int i = 0, iMax = formula.size();                    String op = "+";            while (i < iMax)            {                argStack.pushArgument(formula.get(i++));                Set argSet = evaluateArgument(argStack, name);                argStack.pop();                            while (i < iMax && ((String) formula.get(i)).equals("&"))                {                    i++;                                    argStack.pushArgument(formula.get(i++));                    Set argSet2 = evaluateArgument(argStack, name);                    argStack.pop();                                    Set s1, s2;                                    if (argSet.size() < argSet2.size())                    {                        s1 = argSet;                        s2 = argSet2;                    }                    else                    {                        s2 = argSet;                        s1 = argSet2;                    }                                    Iterator iterator = s1.iterator();                                    argSet = new HashSet();                                    while (iterator.hasNext())                    {                        Object o = iterator.next();                                            if (s2.contains(o))                            argSet.add(o);                    }                }                            if (op.equals("+"))                {                    Iterator iterator = argSet.iterator();                                        while (iterator.hasNext())                        result.add(iterator.next());                                }                else if (op.equals("-"))                {                    Iterator iterator = argSet.iterator();                                    while (iterator.hasNext())                        result.remove(iterator.next());                }                            if (i < iMax)                {                    op = (String) formula.get(i++);                }            }        }        return result;    }          /** Evaluates the expression on top of argStack. The evaluation is optimized in such way that     * it only retrieves information regarding the given user name.     * @param argStack This stack includes all expressions and subexpressions of the current tree     * inside the orginal expression.     * @param name The name of the user for whom the expression should be evaluated.     * @throws ParserException if there is something wrong with the expression. The most common cases are syntax     * errors or circular references within the expression.     * @return An optimized set of users. It is guaranteed that it is correct for the given user     * but it is not guaranteed that it includes all users described by the expression.     */        public Set evaluate(ParserStackIf argStack, String name) throws ParserException    {        return evaluate(argStack, name, 0);    }    /** Evaluates the expression on top of argStack.     * @param argStack This stack includes all expressions and subexpressions of the current tree     * inside the orginal expression.     * @throws ParserException if there is something wrong with the expression. The most common cases are syntax     * errors or circular references within the expression.     * @return The set of users described by the expression.     */        public Set evaluate(ParserStackIf argStack) throws ParserException    {        return evaluate(argStack, null, 0);    }    /** Evaluates an expression. The evaluation is optimized in such way that     * it only retrieves information regarding the given user name.     * @param expression The expression to evaluate     * @param name The name of the user for whom the expression should be evaluated.     * @throws ParserException if there is something wrong with the expression. The most common cases are syntax     * errors or circular references within the expression.     * @return An optimized set of users. It is guaranteed that it is correct for the given user     * but it is not guaranteed that it includes all users described by the expression.     */        public Set evaluateExpression(String expression, String name) throws ParserException    {        ParserStack argStack = new ParserStack();        argStack.pushArgument(expression);                return evaluate(argStack, name);    }    /** Evaluates an expression     * @param expression The expression to evaluate     * @throws ParserException if there is something wrong with the expression. The most common cases are syntax     * errors or circular references within the expression.     * @return The set of users described by the expression.     */        public Set evaluateExpression(String expression) throws ParserException    {        return evaluateExpression(expression, null);    }}/** * $Log: Parser.java,v $ * Revision 1.7  2003/04/13 21:09:56  joerg * Package structure modified * * Revision 1.6  2003/04/13 20:28:01  joerg * Package structure modified * * Revision 1.5  2003/04/13 20:16:42  joerg * Package structure modified * * Revision 1.4  2003/04/07 20:08:49  joerg * Improved JavaDoc. * * Revision 1.3  2003/01/16 21:48:00  joerg * Kleine Bugfixes * * Revision 1.2  2003/01/01 21:04:18  joerg * Copyright-Statement aktualisiert * * Revision 1.1  2002/12/19 15:24:23  joerg * Reparatur des CVS-Repositories * * Revision 1.7  2002/12/09 19:29:17  joerg * Versionsdaten in allen JavaDoc-Klassenbeschreibungen ergaenzt * * Revision 1.6  2002/12/09 16:32:26  joerg * JavaDoc Kommentare ergaenzt * * Revision 1.5  2002/11/27 22:29:53  joerg * Auskommentierten Code entfernt * * Revision 1.4  2002/11/27 16:39:40  joerg * Parameteruebergabe geaendert, um circulaere Recursion * zu erkennen * * Revision 1.3  2002/11/26 21:46:56  joerg * Fehlerbehandlung verbessert * * Revision 1.2  2002/11/26 14:40:49  joerg * Kleine Optimierungen * * Revision 1.1  2002/11/26 10:55:36  joerg * Package exprparser durch parser erstzt. * */