parser.java

这是一个法律事务所系统源码

    static {
	coreElements.addElement(new SetProperty());
    }

    /*
     * User-defined Tags
     */
    static final class Tag implements CoreElement {
        
        private static final String CLOSE_1 = "/>";
        private static final String CLOSE = ">";
        
	public boolean accept(ParseEventListener listener, JspReader reader, 
                              Parser parser) throws JasperException 
	{
            if (reader.peekChar() != '<')
                return false;

            Mark start = reader.mark();
            reader.nextChar();
            String tag = reader.parseToken(false);

            /*
             * Extract the prefix and the short tag name.
             */
            int i = tag.indexOf(':');
            if (i == -1) {
                reader.reset(start);
                return false;
            }
            String prefix = tag.substring(0, i);
            String shortTagName = "";
            if (++i < tag.length()) 
                shortTagName = tag.substring(i);
            
            /*
             * Check if this is a user-defined tag; otherwise we won't touch this...
             */

            TagLibraries libraries = listener.getTagLibraries();
            
            if (!libraries.isUserDefinedTag(prefix, shortTagName)) {
                reader.reset(start);
                return false;
            }

            if (shortTagName == null)
                throw new ParseException(start, "Nothing after the :");

            
            TagLibraryInfo tli = libraries.getTagLibInfo(prefix);
            TagInfo ti = tli.getTag(shortTagName);
            
            if (ti == null)
                throw new ParseException(start, "Unable to locate TagInfo for "+tag);

	    String bc = ti.getBodyContent();

            Hashtable attrs = reader.parseTagAttributes();
            reader.skipSpaces();
            Mark bodyStart = null;
            Mark bodyStop = null;

	    
	    
	    if (reader.matches(CLOSE_1)
		|| bc.equalsIgnoreCase(TagInfo.BODY_CONTENT_EMPTY)) {
		if (reader.matches(CLOSE_1))
		    reader.advance(CLOSE_1.length());
		else
		    throw new ParseException(start, "Body is supposed to be empty for "+tag);

		listener.setTemplateInfo(parser.tmplStart, parser.tmplStop);		
		listener.handleTagBegin(start, reader.mark(), attrs, prefix,
					shortTagName, tli, ti);
		listener.handleTagEnd(start, reader.mark(), prefix, 
				      shortTagName, attrs, tli, ti);
	    } else { 
		// Body can be either
		//     - JSP tags
		//     - tag dependent stuff
		if (reader.matches(CLOSE)) {
		    reader.advance(CLOSE.length());
		    bodyStart = reader.mark();
		    listener.setTemplateInfo(parser.tmplStart, parser.tmplStop);		    
		    listener.handleTagBegin(start, bodyStart, attrs, prefix, 
					    shortTagName, tli, ti);
                    if (bc.equalsIgnoreCase(TagInfo.BODY_CONTENT_TAG_DEPENDENT) ||
                        bc.equalsIgnoreCase(TagInfo.BODY_CONTENT_JSP)) 
                        {
                            String tagEnd = "</"+tag+">";
                            // Parse until the end of the tag body. 
                            // Then skip the tag end... 
                            parser.parse(tagEnd);
                            try {
                                reader.advance(tagEnd.length());
                            } catch (ParseException ex) {
                                throw new ParseException(
                                    start,
                                    Constants.getString("jsp.error.unterminated.user.tag", 
                                        new Object[]{JspUtil.escapeXml(tagEnd)}));
			    }
			    listener.setTemplateInfo(parser.tmplStart, parser.tmplStop);
                            listener.handleTagEnd(parser.tmplStop, reader.mark(), prefix, 
                                                  shortTagName, attrs, tli, ti);
                        } else
                            throw new ParseException(start, 
                                                     "Internal Error: Invalid BODY_CONTENT type");
		} else 
		    throw new ParseException(start, 
					     "Unterminated user-defined tag");
	    }
            return true;
        }
    }

    static {
        coreElements.addElement(new Tag());
    }
    
    

    /*
     * Plugin
     */
    static final class Plugin implements CoreElement {
	private static final String OPEN_PLUGIN  = "<jsp:plugin";
	private static final String END_OPEN_PLUGIN  = ">";
	private static final String CLOSE_PLUGIN = "</jsp:plugin>";
	private static final String OPEN_PARAMS = "<jsp:params>";
	private static final String CLOSE_PARAMS = "</jsp:params>";
	private static final String OPEN_INDIVIDUAL_PARAM = "<jsp:param";
	private static final String CLOSE_INDIVIDUAL_PARAM = "/>";
	private static final String OPEN_FALLBACK = "<jsp:fallback>";
	private static final String CLOSE_FALLBACK = "</jsp:fallback>";

	private static final JspUtil.ValidAttribute[] validAttributes = {
	   new JspUtil.ValidAttribute ("type",true),
	   new JspUtil.ValidAttribute("code", true),
	   new JspUtil.ValidAttribute("codebase"),
	   new JspUtil.ValidAttribute("align"),
	   new JspUtil.ValidAttribute("archive"),
	   new JspUtil.ValidAttribute("height"),
	   new JspUtil.ValidAttribute("hspace"),
	   new JspUtil.ValidAttribute("jreversion"),
	   new JspUtil.ValidAttribute("name"),
	   new JspUtil.ValidAttribute("vspace"),
	   new JspUtil.ValidAttribute("width"),
	   new JspUtil.ValidAttribute("nspluginurl"),
	   new JspUtil.ValidAttribute("iepluginurl")
	};

	public boolean accept(ParseEventListener listener, JspReader reader, 
				Parser parser) throws JasperException 
	{
	    if (reader.matches(OPEN_PLUGIN)) {
		Mark start = reader.mark();
		reader.advance(OPEN_PLUGIN.length());
		Hashtable attrs = reader.parseTagAttributes ();
		reader.skipSpaces ();

	    if (!reader.matches(END_OPEN_PLUGIN))
	        throw new ParseException (reader.mark(),
	                   Constants.getString("jsp.error.plugin.notclosed"));
	    
	    reader.advance (END_OPEN_PLUGIN.length ());
	    reader.skipSpaces ();

		Hashtable param = null;
		String fallback = null;

	        JspUtil.checkAttributes ("plugin", attrs, validAttributes, start);
		if (reader.matches (OPEN_PARAMS)) {
		    param = new Hashtable ();
		    boolean paramsClosed = false;
		    reader.advance (OPEN_PARAMS.length ());

		    /**
		     * Can have more than one param tag. Hence get all the
		     * params.
		     */

		    while (reader.hasMoreInput ()) {
		        reader.skipSpaces ();
		        if (reader.matches (CLOSE_PARAMS)) {
			    paramsClosed = true;
			    reader.advance (CLOSE_PARAMS.length ());
			    break;
			}
		        if (!reader.matches (OPEN_INDIVIDUAL_PARAM))
		    	    throw new ParseException (reader.mark(),
				Constants.getString("jsp.error.paramexpected"));

			reader.parsePluginParamTag(param);
			reader.skipSpaces ();

		        if (!reader.matches (CLOSE_INDIVIDUAL_PARAM))
		    	    throw new ParseException (reader.mark(),
				Constants.getString(
					"jsp.error.closeindividualparam"));
			reader.advance (CLOSE_INDIVIDUAL_PARAM.length ());
		    }
		    if (!paramsClosed)
		    	    throw new ParseException (reader.mark(),
				Constants.getString("jsp.error.closeparams"));
		    reader.skipSpaces ();
		}
		
		if (reader.matches (OPEN_FALLBACK)) {
		    reader.advance(OPEN_FALLBACK.length ());
		    reader.skipSpaces ();
		    Mark fallBackStart = reader.mark ();
		    Mark fallBackStop = reader.skipUntil (CLOSE_FALLBACK);
		    fallback = new String (reader.getChars(fallBackStart,
		    					         fallBackStop));
		    reader.skipSpaces ();
		}

		if (!reader.matches(CLOSE_PLUGIN)) 
		    throw new ParseException(reader.mark(), 
                                          Constants.getString(
					  "jsp.error.unterminated", 
                                           new Object[] { OPEN_PLUGIN }));

		reader.advance(CLOSE_PLUGIN.length());
		Mark stop = reader.mark();
		listener.setTemplateInfo(parser.tmplStart, parser.tmplStop);		
		listener.handlePlugin(start, stop, attrs, param, fallback);
		return true;
	    } else
		return false;
	}
    }

    static {
	coreElements.addElement(new Plugin());
    }

    /*
     * Quoting in template text.
     * Entities &apos; and &quote;
     */
    static final class QuoteEscape implements CoreElement {
        /**
         * constants for escapes
         */
        private static String QUOTED_START_TAG = "<\\%";
        private static String QUOTED_END_TAG = "%\\>";
        private static String START_TAG = "<%";
        private static String END_TAG = "%>";

	private static final String APOS = "&apos;";
	private static final String QUOTE = "&quote;";
        
	public boolean accept(ParseEventListener listener, JspReader reader, Parser parser) 
            throws JasperException 
	{
            try {
		Mark start = reader.mark();
                if (reader.matches(QUOTED_START_TAG)) {
                    reader.advance(QUOTED_START_TAG.length());
		    Mark end = reader.mark();
                    parser.caw.write(START_TAG);
                    parser.flushCharData(start, end);
                    return true;
                } else if (reader.matches(APOS)) {
                    reader.advance(APOS.length());
		    Mark end = reader.mark();
                    parser.caw.write("\'");
                    parser.flushCharData(start, end);
                    return true;
                }
                else if (reader.matches(QUOTE)) {
                    reader.advance(QUOTE.length());
		    Mark end = reader.mark();
                    parser.caw.write("\"");
                    parser.flushCharData(start, end);
                    return true;
                }
            } catch (java.io.IOException ex) {
                System.out.println (ex.getMessage());
            }
            return false;
	}
    }
    
    static {
	coreElements.addElement(new QuoteEscape());
    }

    void flushCharData(Mark start, Mark stop) throws JasperException {
        char[] array = caw.toCharArray();
        if (array.length != 0) // Avoid unnecessary out.write("") statements...
            listener.handleCharData(start, stop, caw.toCharArray());
        caw = new CharArrayWriter();
    }

    public void parse() throws JasperException {
        parse(null);
    }

    public void parse(String until) throws JasperException {
        parse(until, null);
    }
    
    public void parse(String until, Class[] accept) throws JasperException {

	boolean noJspElement = false;
	while (reader.hasMoreInput()) {
            if (until != null && reader.matches(until)) 
                return;

	    // If the file has changed because of a 'push' or a 'pop'
	    // we must flush the character data for the old file.
	    if (!reader.mark().getFile().equals(currentFile)) {
		flushCharData(tmplStart, tmplStop);
		currentFile = reader.mark().getFile();
		tmplStart = reader.mark();
	    }
	    
	    Enumeration e = coreElements.elements(); 

            if (accept != null) {
                Vector v = new Vector();
                while (e.hasMoreElements()) {
                    CoreElement c = (CoreElement) e.nextElement();
                    for(int i = 0; i < accept.length; i++)
                        if (c.getClass().equals(accept[i]))
                            v.addElement(c);
                }
                e = v.elements();
            }

	    boolean accepted = false;
	    while (e.hasMoreElements()) {
		CoreElement c = (CoreElement) e.nextElement();
		Mark m = reader.mark();
		if (c.accept(listener, reader, this)) {
                    Constants.message("jsp.message.accepted",
                                      new Object[] { c.getClass().getName(), m },
                                      Logger.DEBUG);
		    accepted = true;
		    noJspElement = false;
		    break;
		} 
	    }
	    if (!accepted) {

		// This is a hack. "reader.nextContent()" will just return 
		// after it sees "<" -- not necessarily a JSP element. Using
		// a boolean we will ensure that tmplStart changes only when
		// strictly necessary.
		if (noJspElement == false) {
		    tmplStart = reader.mark();
		    noJspElement = true;
		}
		String s = reader.nextContent();
		tmplStop = reader.mark();
		caw.write(s, 0, s.length());
	    }
	}
	flushCharData(tmplStart, tmplStop);
    }
}