private ASTNode parseSimpleExpression(Token token)
    	throws Exception {

        LeolaTokenType signType = null;  // type of leading sign (if any)

        Token leadingToken = token;
        // Look for a leading + or - sign.
        LeolaTokenType tokenType = token.getType();
        if ( (tokenType == STAR) ||
             (tokenType == PLUS) ||             
        	 (tokenType == MINUS)) {            
            signType = tokenType;
            token = nextToken();  // consume the + or - or *            
        }

        // Parse a term and make the root of its tree the root node.
        ASTNode rootNode = parseTerm(token);

        // Was there a leading - sign?
        if(signType!=null) {
            if (signType == MINUS) {
    
                // Create a NEGATE node and adopt the current tree
                // as its child. The NEGATE node becomes the new root node.
                UnaryExpr negateNode = new UnaryExpr((Expr)rootNode, UnaryOp.NEGATE);
                rootNode = negateNode;
            }
            else if(signType == STAR) {
                if(!this.isNamedParameter) {
                    throwParseError(leadingToken, LeolaErrorCode.INVALID_ARGS_EXPANSION);
                }
                rootNode.appendFlag(ASTAttributes.IS_ARG_ARRAY_EXPAND);
            }
        }

        token = currentToken();
        tokenType = token.getType();

        if ( tokenType.equals(LeolaTokenType.IS)) {
        	IsExpr isExpr = (IsExpr)(new IsExprParser((Expr)rootNode, this).parse(token));
        	rootNode = isExpr;

        	token = currentToken();
            tokenType = token.getType();
        } 

        // Loop over additive operators.
        while (ADD_OPS.contains(tokenType)) {
            LeolaTokenType operator = tokenType;

            token = nextToken();  // consume the operator

            // Parse another term.  The operator node adopts
            // the term's tree as its second child.
            ASTNode termNode = parseTerm(token);

            BinaryExpr bExpr = new BinaryExpr( (Expr)rootNode
            		                         , (Expr)termNode
            		                         , operator.toBinaryOp());

            // The operator node becomes the new root node.
            rootNode = bExpr;

            token = currentToken();
            tokenType = token.getType();
        }

        return rootNode;
    }