287 lines · 9.9 KB · Java
RawDownload
/* * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code 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 * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package javax.management.loading; import static com.sun.jmx.defaults.JmxProperties.MLET_LOGGER; import java.io.BufferedReader;import java.io.File;import java.io.IOException;import java.io.InputStreamReader;import java.io.Reader;import java.net.URL;import java.net.URLConnection;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.logging.Level; /** * This class is used for parsing URLs. * * @since 1.5 */class MLetParser { /*  * ------------------------------------------  *   PRIVATE VARIABLES  * ------------------------------------------  */     /**     * The current character     */    private int c;     /**     * Tag to parse.     */    private static String tag = "mlet";    /*  * ------------------------------------------  *   CONSTRUCTORS  * ------------------------------------------  */     /**     * Create an MLet parser object     */    public MLetParser() {    }     /*     * ------------------------------------------     *   PUBLIC METHODS     * ------------------------------------------     */     /**     * Scan spaces.     */    public void skipSpace(Reader in) throws IOException {        while ((c >= 0) && ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r'))) {            c = in.read();        }    }     /**     * Scan identifier     */    public String scanIdentifier(Reader in) throws IOException {        StringBuilder buf = new StringBuilder();        while (true) {            if (((c >= 'a') && (c <= 'z')) ||                ((c >= 'A') && (c <= 'Z')) ||                ((c >= '0') && (c <= '9')) || (c == '_')) {                buf.append((char)c);                c = in.read();            } else {                return buf.toString();            }        }    }     /**     * Scan tag     */    public Map<String,String> scanTag(Reader in) throws IOException {        Map<String,String> atts = new HashMap<String,String>();        skipSpace(in);        while (c >= 0 && c != '>') {            if (c == '<')                throw new IOException("Missing '>' in tag");            String att = scanIdentifier(in);            String val = "";            skipSpace(in);            if (c == '=') {                int quote = -1;                c = in.read();                skipSpace(in);                if ((c == '\'') || (c == '\"')) {                    quote = c;                    c = in.read();                }                StringBuilder buf = new StringBuilder();                while ((c > 0) &&                       (((quote < 0) && (c != ' ') && (c != '\t') &&                         (c != '\n') && (c != '\r') && (c != '>'))                        || ((quote >= 0) && (c != quote)))) {                    buf.append((char)c);                    c = in.read();                }                if (c == quote) {                    c = in.read();                }                skipSpace(in);                val = buf.toString();            }            atts.put(att.toLowerCase(), val);            skipSpace(in);        }        return atts;    }     /**     * Scan an html file for <mlet> tags     */    public List<MLetContent> parse(URL url) throws IOException {        String mth = "parse";        // Warning Messages        String requiresTypeWarning = "<arg type=... value=...> tag requires type parameter.";        String requiresValueWarning = "<arg type=... value=...> tag requires value parameter.";        String paramOutsideWarning = "<arg> tag outside <mlet> ... </mlet>.";        String requiresCodeWarning = "<mlet> tag requires either code or object parameter.";        String requiresJarsWarning = "<mlet> tag requires archive parameter.";         URLConnection conn;         conn = url.openConnection();        Reader in = new BufferedReader(new InputStreamReader(conn.getInputStream(),                                                             "UTF-8"));         // The original URL may have been redirected - this        // sets it to whatever URL/codebase we ended up getting        //        url = conn.getURL();         List<MLetContent> mlets = new ArrayList<MLetContent>();        Map<String,String> atts = null;         List<String> types = new ArrayList<String>();        List<String> values = new ArrayList<String>();         // debug("parse","*** Parsing " + url );        while(true) {            c = in.read();            if (c == -1)                break;            if (c == '<') {                c = in.read();                if (c == '/') {                    c = in.read();                    String nm = scanIdentifier(in);                    if (c != '>')                        throw new IOException("Missing '>' in tag");                    if (nm.equalsIgnoreCase(tag)) {                        if (atts != null) {                            mlets.add(new MLetContent(url, atts, types, values));                        }                        atts = null;                        types = new ArrayList<String>();                        values = new ArrayList<String>();                    }                } else {                    String nm = scanIdentifier(in);                    if (nm.equalsIgnoreCase("arg")) {                        Map<String,String> t = scanTag(in);                        String att = t.get("type");                        if (att == null) {                            MLET_LOGGER.logp(Level.FINER,                                    MLetParser.class.getName(),                                    mth, requiresTypeWarning);                            throw new IOException(requiresTypeWarning);                        } else {                            if (atts != null) {                                types.add(att);                            } else {                                MLET_LOGGER.logp(Level.FINER,                                        MLetParser.class.getName(),                                        mth, paramOutsideWarning);                                throw new IOException(paramOutsideWarning);                            }                        }                        String val = t.get("value");                        if (val == null) {                            MLET_LOGGER.logp(Level.FINER,                                    MLetParser.class.getName(),                                    mth, requiresValueWarning);                            throw new IOException(requiresValueWarning);                        } else {                            if (atts != null) {                                values.add(val);                            } else {                                MLET_LOGGER.logp(Level.FINER,                                        MLetParser.class.getName(),                                        mth, paramOutsideWarning);                                throw new IOException(paramOutsideWarning);                            }                        }                    } else {                        if (nm.equalsIgnoreCase(tag)) {                            atts = scanTag(in);                            if (atts.get("code") == null && atts.get("object") == null) {                                MLET_LOGGER.logp(Level.FINER,                                        MLetParser.class.getName(),                                        mth, requiresCodeWarning);                                throw new IOException(requiresCodeWarning);                            }                            if (atts.get("archive") == null) {                                MLET_LOGGER.logp(Level.FINER,                                        MLetParser.class.getName(),                                        mth, requiresJarsWarning);                                throw new IOException(requiresJarsWarning);                            }                        }                    }                }            }        }        in.close();        return mlets;    }     /**     * Parse the document pointed by the URL urlname     */    public List<MLetContent> parseURL(String urlname) throws IOException {        // Parse the document        //        URL url;        if (urlname.indexOf(':') <= 1) {            String userDir = System.getProperty("user.dir");            String prot;            if (userDir.charAt(0) == '/' ||                userDir.charAt(0) == File.separatorChar) {                prot = "file:";            } else {                prot = "file:/";            }            url =                new URL(prot + userDir.replace(File.separatorChar, '/') + "/");            url = new URL(url, urlname);        } else {            url = new URL(urlname);        }        // Return list of parsed MLets        //        return parse(url);    } }