parser.java

来自「cwbbs 云网论坛源码」· Java 代码 · 共 521 行 · 第 1/2 页

package com.cloudwebsoft.framework.template;

import java.util.regex.Pattern;
import java.io.BufferedReader;
import java.util.Stack;
import java.util.List;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import com.cloudwebsoft.framework.template.plugin.PluginMgr;
import java.util.regex.Matcher;
import javax.servlet.http.HttpServletRequest;
import com.cloudwebsoft.framework.util.LogUtil;
import java.util.ArrayList;
import com.cloudwebsoft.framework.template.plugin.PluginUnit;
import cn.js.fan.util.ErrMsgException;
import java.io.Reader;


public class Parser {

    public Parser() {
    }

    static final Pattern varPat = Pattern.compile("\\$(\\S+)",
                                                  Pattern.DOTALL |
                                                  Pattern.CASE_INSENSITIVE);
    static final Pattern beginPat = Pattern.compile(
            "<!--\\s*begin:(\\S+)\\s*(.*?)-->",
            Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
    static final Pattern fieldVarPat = Pattern.compile("@(\\S+)",
            Pattern.DOTALL |
            Pattern.CASE_INSENSITIVE);
    static final Pattern endPat = Pattern.compile(
            "<!--\\s*?end:(\\S+)(.*?)-->",
            Pattern.DOTALL | Pattern.CASE_INSENSITIVE);

    static final Pattern patArray[] = {
                                      varPat,
                                      beginPat,
                                      fieldVarPat,
                                      endPat
    };

    static final int tokenTypeArray[] = {Token.VAR, Token.BEGIN, Token.FIELD,
                                        Token.END};

    
    public ITemplate parse(String fileName) throws IOException,ErrMsgException {
        

        return parse(fileName, "utf-8");
    }

    
    public ITemplate parse(String fileName, String charsetName) throws
            IOException,ErrMsgException {
        FileInputStream fileStream = new FileInputStream(fileName);
        

        ITemplate template = null;
        try {
            template = parse(fileStream, charsetName);
        }
        finally {
            fileStream.close();
        }
        return template;
    }

    
    public ITemplate parse(InputStream stream, String charsetName) throws
            IOException,ErrMsgException {
        if (charsetName == null) charsetName = "utf-8";
        InputStreamReader streamReader = new InputStreamReader(stream,
                charsetName);
        BufferedReader reader = new BufferedReader(streamReader);
        ITemplate template = null;
        try {
            template = parse(reader);
        }
        finally {
            streamReader.close();
            reader.close();
        }
        return template;
    }

    public ITemplate parse(Reader reader) throws
            IOException,ErrMsgException {
        BufferedReader bufreader = new BufferedReader(reader);
        ITemplate template = null;
        try {
            template = parse(bufreader);
        }
        finally {
            reader.close();
            bufreader.close();
        }
        return template;
    }

    public ListPart getListPartByName(String line) {
        
        Matcher m = beginPat.matcher(line);
        boolean result = m.find();
        String name = "";
        String propStr = "";
        
        if (result) {
            name = m.group(1);
            if (m.groupCount() >= 2)
                propStr = m.group(2);
        }
        PluginMgr pm = new PluginMgr();
        ListPart lp = (ListPart) pm.getPluginUnit(name).getITemplate();
        
        if (!propStr.equals(""))
            lp.parseProps(propStr);
        return lp;
    }

    public VarPart getVarPartByNameString(String nameStr) throws ErrMsgException {
        
        
        
        
        
        Pattern varNamePat = Pattern.compile(
                "\\$(\\S+)\\.(\\S+)\\((\\S+)\\)\\.([^\\(]+)?(\\((.*?)\\))?",
                Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
        Matcher m = varNamePat.matcher(nameStr);
        
        if (m.find()) {
            if (m.groupCount() < 5)
                throw new IllegalArgumentException(nameStr +
                        " is invalid! Regexp match group count is " +
                        m.groupCount());
            String name = m.group(1);
            String keyName = m.group(2);
            String keyValue = m.group(3);
            String field = m.group(4);
            String props = "";
            if (m.groupCount() >= 6) {
                props = m.group(6);
            }
            PluginMgr pm = new PluginMgr();
            PluginUnit pu = pm.getPluginUnit(name);
            if (pu == null)
                throw new IllegalArgumentException(name +
                        " is not found in plugin units. Name string is " +
                        nameStr);
            VarPart vp = (VarPart) pu.getITemplate();
            if (vp==null)
                throw new IllegalArgumentException(
                        " ITemplate is not found. Name string is " +
                        nameStr);
            vp.setName(name);
            vp.setKeyName(keyName);
            vp.setKeyValue(keyValue);
            
            vp.setField(field);
            if (props != null && !props.equals(""))
                vp.parseProps(props);
            return vp;
        } else {
            
            Pattern varNamePat2 = Pattern.compile(
                    
                    "\\$([A-Z0-9a-z]+)\\.([^\\(]+)(\\((.*?)\\))?",
                    Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
            m = varNamePat2.matcher(nameStr);
            if (m.find()) {
                if (m.groupCount() < 2) {
                    throw new IllegalArgumentException(nameStr +
                            " is invalid! varNamePat2 match group count is " +
                            m.groupCount());
                }
                String name = m.group(1);
                String field = m.group(2);
                String props = "";
                if (m.groupCount() >= 4) {
                    props = m.group(4);
                }
                PluginMgr pm = new PluginMgr();

                
               PluginUnit pu = pm.getPluginUnit(name);
               if (pu == null)
                   throw new ErrMsgException("Plugin unit of " + name +
                                             " is not found!");
               VarPart vp = (VarPart) pu.getITemplate();
               if (vp == null)
                   throw new ErrMsgException("ITemplate of " + name +
                                             " is not found!");
               vp.setName(name);
               vp.setField(field);
               if (props != null && !props.equals(""))
                   vp.parseProps(props);
               return vp;
            } else
                throw new IllegalArgumentException(nameStr + " is invalid!");
        }
    }

    public Token parseLine(String line) {
        Token token = new Token();

        
        

        if (line.startsWith("<!--") && line.endsWith("-->")) {
            int commentBeginPos = line.indexOf("<!--") + "<!--".length();
            int commentEndPos = line.indexOf("-->", commentBeginPos);

            String tag = line.substring(commentBeginPos, commentEndPos).trim();
            tag = line;
            
            int nPatterns = patArray.length;
            Matcher m = null;
            for (int i = 0; i < nPatterns; i++) {
                Pattern pattern = patArray[i];
                m = pattern.matcher(tag);
                if (m.find()) {
                    token.setType(tokenTypeArray[i]);
                    break;
                }
            }

            if (token.getType() == Token.BEGIN) { 
                token.setName(m.group(1));
            } else if (token.getType() == Token.END) {
                token.setName(m.group(1));
            }

            return token;
        }

        int begin = 0;
        List posPairs = null;

        
        
        
        
        while (true) {
            int lBracketPos = line.indexOf("{", begin);
            if (lBracketPos < 0)break;

            int rBracketPos = line.indexOf("}", lBracketPos);
            if (rBracketPos < 0)break;

            
            int nestedLeftBracketPos = line.indexOf("{", lBracketPos + 1);
            while (nestedLeftBracketPos >= 0 &&
                   nestedLeftBracketPos < rBracketPos) {
                lBracketPos = nestedLeftBracketPos;
                nestedLeftBracketPos = line.indexOf("{", lBracketPos + 1);
            }