parser.java

iiitAccessServer是一个用Java编写的基于规则的企业鉴别系统。它作为一个服务器工作

/*******************************************************************************
 * Copyright (C) 2002, 2003
 * ingenieurbuero fuer innovative informationstechnik (iiit)
 * Dipl.-Ing. Joerg Beckmann, Dortmund, Germany
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * version $Id: Parser.java,v 1.7 2003/04/13 21:09:56 joerg Exp $
 ******************************************************************************/

package de.iiit.access.server.plugins.parser;

import de.iiit.access.common.api.*;

import de.iiit.access.server.*;
import de.iiit.access.server.api.*;

import java.util.*;
import java.util.regex.*;

import org.apache.log4j.Logger;

/** Provides a parser for operations on sets.
 *
 * <p>Every expression is evaluated from left to right. The operator '&' has
 * a higher priority then '+' and '-'.</p>
 *
 * Examples:
 *
 * <CODE> <PRE>
 * A1 = { a1, a2 }
 * A2 = { a3, a4 }
 * A3 = { a5, a6 }
 * A12 = A1 + A2 = { a1, a2, a3, a4 }
 * A13 = A1 + A3 = { a1, a2, a5, a6 }
 * A23 = A2 + A3 = { a3, a4, a3, a4 }
 * A  = A1 + A2 + A3 = { a1, a2, a3, a4, a5, a6 }
 * N  = { }
 *
 * A1 + A2 = A2 + A1 = { a1, a2, a3, a4 }
 * A1 + A1 = A1
 * A  + A1 = A + A2 = A + A3 = A
 * A1 - A1 = N
 * A1 - A2 = A1
 * A1 - A  = N
 * A - A1 - A2 = A - (A1 + A2) = A3
 *
 * A  -  A1       = { a3, a4, a5, a6 }
 * A  -  A1 + A2  = (A -  A1) + A2  = { a3, a4, a5, a6 }
 * A  -  A2 + A1  = (A -  A2) + A1  = { a1, a2, a5, a6 }
 * A  - (A1 + A2) =  A - (A2  + A1) = A3
 * A  +  A1 - A2  = (A +  A1) - A2  = { a1, a2, a5, a6 }
 * A  +  A2 - A1  = (A +  A2) - A1  = { a3, a4, a5, a6 }
 * A  +  A1 - A1  = (A +  A1) - A1  = { a3, a4, a5, a6 }
 * A  -  A1 + A1  = (A -  A1) + A1  = { a1, a2, a3, a4, a5, a6 }
 * A1 -  A  = N
 * A1 -  A2 = A1
 *
 *  A1 &  A2 = N
 *  A  &  N  = N
 *  A  &  A1 & A2  = (A & A1) & A2 = N
 *  A  & (A1 & A2) =  N
 * (A1 + A2) & (A2 + A3) = (A2 +  A1) & (A3  + A2) = A2
 *  A1 + A2  &  A2 + A3  =  A1 + (A2  &  A2) + A3  = A
 *  A2 + A1  &  A3 + A2  =  A2 + (A1  &  A3) + A2  = A2
 *
 * A  & A2 = A2 & A  = A2
 * A1 & A2 = A2 & A1 = N
 * </PRE> </CODE>
 * @version $Revision: 1.7 $ $Date: 2003/04/13 21:09:56 $
 */
public class Parser
{
    /** CVS Version Tag */
    private static final String vcid = "$Id: Parser.java,v 1.7 2003/04/13 21:09:56 joerg Exp $";
    
    private Logger logger = Logger.getLogger(this.getClass());

    private static Pattern pOpenBrace    = Pattern.compile("\\s*(\\()\\s*");              // (
    private static Pattern pBrace        = Pattern.compile("\\s*([\\(\\)])\\s*");         // ( or )
    private static Pattern pArgument     = Pattern.compile("\\s*([a-zA-Z0-9_]+)\\s*");    // Token 
    private static Pattern pOperator     = Pattern.compile("\\s*([&+\\-])\\s*");          // + or - or &
    private static Pattern pSpace        = Pattern.compile("\\s*$");                      // Nothing but whitespace
    private static Pattern pArgumentOnly = Pattern.compile("^\\s*([a-zA-Z0-9_]+)\\s*$");  // Token without calculations

    private boolean returnEmptySets = false;
    
    private ResolverPluginIf resolver = null;

    /** Creates a new instance of Parser. The AccessServer is asked for the
     * ResolverPlugin to use for the evaluations.
     */
    public Parser()
    {
        resolver = AccessServer.getResolverPlugin();
    }
    
    /** Creates a new instance of Parser.
     * @param resolver The ResolverPlugin to use for the evaluations.
     */    
    public Parser(ResolverPluginIf resolver)
    {
        this.resolver = resolver;
    }
    
    /** Sets whether the parser shall empty sets or null values when nothing was found.
     * @param flag true when empty sets shall be returned or false if null shall be returned
     */    
    public void setReturnEmptySets(boolean flag)
    {
        returnEmptySets = flag;
    }
    
    /** Retrieves whether the parser shall empty sets or null values when nothing was found.
     * @return true when empty sets shall be returned or false if null shall be returned
     */    
    public boolean getReturnEmptySets()
    {
        return returnEmptySets;
    }
    
    private Set evaluateArgument(ParserStackIf argStack, String name) throws ParserException
    {
        Set result = null;
        Class c = null;
        Object argument = argStack.peek();
        try
        {
            c = Class.forName("java.util.Set");
        }
        catch(Exception e)
        {
            logger.error("Exception catched", e);
        }
            
        if (argument.getClass().equals(vcid.getClass())) // Is it a String?
        {
            if (resolver != null)
            {
                if (name != null)
                    result = resolver.resolve(argStack, name);
                else
                    result = resolver.resolve(argStack);
            }
        
            if (result == null)
            {
                result = new HashSet();
                
                if (! returnEmptySets)
                    result.add(argument);
            }
        }
        else if (c.isAssignableFrom(argument.getClass())) // Is it a kind of Set
        {
            result = (Set) argument;
        }
        else
            throw new ParserException("Internal parser error, should not happen.");
        
        return result;
    }

    private int handleBraces(ParserStackIf argStack, String name, Vector formula, Matcher mOpenBrace, int position, int startPos) throws ParserException
    {
        int s = mOpenBrace.end();
                        
        String expression = (String) argStack.peek();
        String subExpression = expression.substring(s);
            
        Matcher mBrace = pBrace.matcher(subExpression);

        boolean loop2 = true;
        int braceCount = 1;
        int e = s;
            
        while (loop2)
        {
            if (mBrace.find())
            {
                if (mBrace.group(1).equals("("))
                    braceCount++;
                else if (--braceCount == 0)
                    loop2 = false;
            }
            else
                throw new ParserException("Matching brace not found near position " 
                                            + (position + startPos) + " in <" + expression + ">");
        }
            
        subExpression = subExpression.substring(0, mBrace.start());
            
        logger.debug("Sub-expression = <" + subExpression + ">");

        argStack.pushArgument(subExpression);
        formula.add(evaluate(argStack, name, position + s));
        argStack.pop();
                
        return s + mBrace.end();
    }
    
    private Set evaluate(ParserStackIf argStack, String name, int position) throws ParserException
    {
        HashSet result = null;
        Vector formula = new Vector();
        int startPos = 0;
        
        String expression = (String) argStack.peek();
        
        Matcher mArgumentOnly = pArgumentOnly.matcher(expression);