mosgi/jmx.agent/src/main/java/org/apache/felix/mosgi/jmx/agent/mx4j/loading/MLetParser.java - felix - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.felix.mosgi.jmx.agent.mx4j.loading;

 import java.lang.reflect.Constructor;
 import java.util.ArrayList;
 import java.util.List;

 import javax.management.MalformedObjectNameException;
 import javax.management.ObjectName;
 import javax.management.loading.MLet;

 /**
  * The parser for MLet files, as specified in the JMX documentation.
  * This parser is case insensitive regards to the MLet tags: MLET is equal to mlet and to MLet.
  * This parser also supports XML-style comments in the file.
  *
  * @author <a href="mailto:biorn_steedom@users.sourceforge.net">Simone Bordet</a>
  * @version $Revision: 1.1.1.1 $
  */
 public class MLetParser
 {
    public static final String OPEN_COMMENT = "<!--";
    public static final String CLOSE_COMMENT = "-->";

    public static final String OPEN_BRACKET = "<";
    public static final String CLOSE_BRACKET = ">";

    public static final String MLET_TAG = "MLET";
    public static final String CODE_ATTR = "CODE";
    public static final String OBJECT_ATTR = "OBJECT";
    public static final String ARCHIVE_ATTR = "ARCHIVE";
    public static final String CODEBASE_ATTR = "CODEBASE";
    public static final String NAME_ATTR = "NAME";
    public static final String VERSION_ATTR = "VERSION";

    public static final String ARG_TAG = "ARG";
    public static final String TYPE_ATTR = "TYPE";
    public static final String VALUE_ATTR = "VALUE";

    private MLet mlet;

    /**
     * Creates a new MLetParser
     */
    public MLetParser()
    {
    }

    /**
     * Creates a new MLetParser
     * @param mlet The MLet used to resolve classes specified in the ARG tags.
     */
    public MLetParser(MLet mlet)
    {
       this.mlet = mlet;
    }

    /**
     * Parses the given content, that must contains a valid MLet file.
     *
     * @param content The content to parse
     * @return A list of {@link MLetTag}s
     * @throws MLetParseException If the content is not a valid MLet file
     */
    public List parse(String content) throws MLetParseException
    {
       if (content == null) throw new MLetParseException("MLet file content cannot be null");

       // Strip comments
       content = stripComments(content.trim());
       content = convertToUpperCase(content);

       ArrayList mlets = parseMLets(content);
       if (mlets.size() < 1) throw new MLetParseException("MLet file is empty");

       ArrayList mletTags = new ArrayList();
       for (int i = 0; i < mlets.size(); ++i)
       {
          String mletTag = (String)mlets.get(i);

          MLetTag tag = parseMLet(mletTag);
          mletTags.add(tag);
       }

       return mletTags;
    }

    private MLetTag parseMLet(String content) throws MLetParseException
    {
       MLetTag tag = new MLetTag();
       parseMLetAttributes(tag, content);
       parseMLetArguments(tag, content);
       return tag;
    }

    private ArrayList parseMLets(String content) throws MLetParseException
    {
       ArrayList list = new ArrayList();
       int start = 0;
       int current = -1;
       while ((current = findOpenTag(content, start, MLET_TAG)) >= 0)
       {
          int end = findCloseTag(content, current + 1, MLET_TAG, true);
          if (end < 0) throw new MLetParseException("MLET tag not closed at index: " + current);

          String mlet = content.substring(current, end);
          list.add(mlet);

          start = end + 1;
       }
       return list;
    }

    private void parseMLetArguments(MLetTag tag, String content) throws MLetParseException
    {
       int start = 0;
       int current = -1;
       while ((current = findOpenTag(content, start, ARG_TAG)) >= 0)
       {
          int end = findCloseTag(content, current + 1, ARG_TAG, false);
          if (end < 0) throw new MLetParseException("ARG tag not closed");

          String arg = content.substring(current, end);

          int type = arg.indexOf(TYPE_ATTR);
          if (type < 0) throw new MLetParseException("Missing TYPE attribute");

          int value = arg.indexOf(VALUE_ATTR);
          if (value < 0) throw new MLetParseException("Missing VALUE attribute");

          String className = findAttributeValue(arg, type, TYPE_ATTR);
          tag.addArg(className, convertToObject(className, findAttributeValue(arg, value, VALUE_ATTR)));

          start = end + 1;
       }
    }

    private void parseMLetAttributes(MLetTag tag, String content) throws MLetParseException
    {
       int end = content.indexOf(CLOSE_BRACKET);
       String attributes = content.substring(0, end);

       // Find mandatory attributes
       int archive = -1;
       int object = -1;
       int code = -1;

       archive = attributes.indexOf(ARCHIVE_ATTR);
       if (archive < 0) throw new MLetParseException("Missing ARCHIVE attribute");

       code = attributes.indexOf(CODE_ATTR);
       object = attributes.indexOf(OBJECT_ATTR);
       if (code < 0 && object < 0) throw new MLetParseException("Missing CODE or OBJECT attribute");
       if (code > 0 && object > 0) throw new MLetParseException("CODE and OBJECT attributes cannot be both present");

       if (code >= 0)
          tag.setCode(findAttributeValue(attributes, code, CODE_ATTR));
       else
          tag.setObject(findAttributeValue(attributes, object, OBJECT_ATTR));

       tag.setArchive(findAttributeValue(attributes, archive, ARCHIVE_ATTR));

       // Look for optional attributes
       int codebase = attributes.indexOf(CODEBASE_ATTR);
       if (codebase >= 0) tag.setCodeBase(findAttributeValue(attributes, codebase, CODEBASE_ATTR));

       int name = attributes.indexOf(NAME_ATTR);
       if (name >= 0)
       {
          String objectName = findAttributeValue(attributes, name, NAME_ATTR);
          try
          {
             tag.setName(new ObjectName(objectName));
          }
          catch (MalformedObjectNameException x)
          {
             throw new MLetParseException("Invalid ObjectName: " + objectName);
          }
       }

       int version = attributes.indexOf(VERSION_ATTR);
       if (version >= 0) tag.setVersion(findAttributeValue(attributes, version, VERSION_ATTR));
    }

    private String findAttributeValue(String content, int start, String attribute) throws MLetParseException
    {
       int equal = content.indexOf('=', start);
       if (equal < 0) throw new MLetParseException("Missing '=' for attribute");

       // Ensure no garbage
       if (!attribute.equals(content.substring(start, equal).trim())) throw new MLetParseException("Invalid attribute");

       int begin = content.indexOf('"', equal + 1);
       if (begin < 0) throw new MLetParseException("Missing quotes for attribute value");

       // Ensure no garbage
       if (content.substring(equal + 1, begin).trim().length() != 0) throw new MLetParseException("Invalid attribute value");

       int end = content.indexOf('"', begin + 1);
       if (end < 0) throw new MLetParseException("Missing quote for attribute value");

       return content.substring(begin + 1, end).trim();
    }

    private int findOpenTag(String content, int start, String tag)
    {
       String opening = new StringBuffer(OPEN_BRACKET).append(tag).toString();
       return content.indexOf(opening, start);
    }

    private int findCloseTag(String content, int start, String tag, boolean strictSyntax)
    {
       int count = 1;

       do
       {
          int close = content.indexOf(CLOSE_BRACKET, start);
          if (close < 0)
          {
             return -1;
          }
          int open = content.indexOf(OPEN_BRACKET, start);
          if (open >= 0 && close > open)
          {
             ++count;
          }
          else
          {
             --count;
             if (count == 0)
             {
                // Either I found the closing bracket of the open tag,
                // or the closing tag
                if (!strictSyntax || (strictSyntax && content.charAt(close - 1) == '/'))
                {
                   // Found the closing tag
                   return close + 1;
                }
                else
                {
                   // Found the closing bracket of the open tag, go for the full closing tag
                   String closing = new StringBuffer(OPEN_BRACKET).append("/").append(tag).append(CLOSE_BRACKET).toString();
                   close = content.indexOf(closing, start);
                   if (close < 0)
                      return -1;
                   else
                      return close + closing.length();
                }
             }
          }

          start = close + 1;
       }
       while (true);
    }

    private String stripComments(String content) throws MLetParseException
    {
       StringBuffer buffer = new StringBuffer();
       int start = 0;
       int current = -1;
       while ((current = content.indexOf(OPEN_COMMENT, start)) >= 0)
       {
          int end = content.indexOf(CLOSE_COMMENT, current + 1);

          if (end < 0) throw new MLetParseException("Missing close comment tag at index: " + current);

          String stripped = content.substring(start, current);
          buffer.append(stripped);
          start = end + CLOSE_COMMENT.length();
       }
       String stripped = content.substring(start, content.length());
       buffer.append(stripped);
       return buffer.toString();
    }

    private String convertToUpperCase(String content) throws MLetParseException
    {
       StringBuffer buffer = new StringBuffer();
       int start = 0;
       int current = -1;
       while ((current = content.indexOf("\"", start)) >= 0)
       {
          int end = content.indexOf("\"", current + 1);

          if (end < 0) throw new MLetParseException("Missing closing quote at index: " + current);

          String converted = content.substring(start, current).toUpperCase();
          buffer.append(converted);
          String quoted = content.substring(current, end + 1);
          buffer.append(quoted);
          start = end + 1;
       }
       String converted = content.substring(start, content.length()).toUpperCase();
       buffer.append(converted);
       return buffer.toString();
    }

    private Object convertToObject(String clsName, String value) throws MLetParseException
    {
       try
       {
          if (clsName.equals("boolean") || clsName.equals("java.lang.Boolean"))
             return Boolean.valueOf(value);
          else if (clsName.equals("byte") || clsName.equals("java.lang.Byte"))
             return Byte.valueOf(value);
          else if (clsName.equals("char") || clsName.equals("java.lang.Character"))
          {
             char ch = 0;
             if (value.length() > 0) ch = value.charAt(0);
             return new Character(ch);
          }
          else if (clsName.equals("short") || clsName.equals("java.lang.Short"))
             return Short.valueOf(value);
          else if (clsName.equals("int") || clsName.equals("java.lang.Integer"))
             return Integer.valueOf(value);
          else if (clsName.equals("long") || clsName.equals("java.lang.Long"))
             return Long.valueOf(value);
          else if (clsName.equals("float") || clsName.equals("java.lang.Float"))
             return Float.valueOf(value);
          else if (clsName.equals("double") || clsName.equals("java.lang.Double"))
             return Double.valueOf(value);
          else if (clsName.equals("java.lang.String"))
             return value;
          else if (mlet != null)
          {
             try
             {
                Class cls = mlet.loadClass(clsName);
                Constructor ctor = cls.getConstructor(new Class[]{String.class});
                return ctor.newInstance(new Object[]{value});
             }
             catch (Exception ignored)
             {
             }
          }
       }
       catch (NumberFormatException x)
       {
          throw new MLetParseException("Invalid value: " + value);
       }
       return null;
    }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.felix.mosgi.jmx.agent.mx4j.loading;

	import java.lang.reflect.Constructor;
	import java.util.ArrayList;
	import java.util.List;

	import javax.management.MalformedObjectNameException;
	import javax.management.ObjectName;
	import javax.management.loading.MLet;

	/**
	* The parser for MLet files, as specified in the JMX documentation.
	* This parser is case insensitive regards to the MLet tags: MLET is equal to mlet and to MLet.
	* This parser also supports XML-style comments in the file.
	*
	* @author <a href="mailto:biorn_steedom@users.sourceforge.net">Simone Bordet</a>
	* @version $Revision: 1.1.1.1 $
	*/
	public class MLetParser
	{
	public static final String OPEN_COMMENT = "<!--";
	public static final String CLOSE_COMMENT = "-->";

	public static final String OPEN_BRACKET = "<";
	public static final String CLOSE_BRACKET = ">";

	public static final String MLET_TAG = "MLET";
	public static final String CODE_ATTR = "CODE";
	public static final String OBJECT_ATTR = "OBJECT";
	public static final String ARCHIVE_ATTR = "ARCHIVE";
	public static final String CODEBASE_ATTR = "CODEBASE";
	public static final String NAME_ATTR = "NAME";
	public static final String VERSION_ATTR = "VERSION";

	public static final String ARG_TAG = "ARG";
	public static final String TYPE_ATTR = "TYPE";
	public static final String VALUE_ATTR = "VALUE";

	private MLet mlet;

	/**
	* Creates a new MLetParser
	*/
	public MLetParser()
	{
	}

	/**
	* Creates a new MLetParser
	* @param mlet The MLet used to resolve classes specified in the ARG tags.
	*/
	public MLetParser(MLet mlet)
	{
	this.mlet = mlet;
	}

	/**
	* Parses the given content, that must contains a valid MLet file.
	*
	* @param content The content to parse
	* @return A list of {@link MLetTag}s
	* @throws MLetParseException If the content is not a valid MLet file
	*/
	public List parse(String content) throws MLetParseException
	{
	if (content == null) throw new MLetParseException("MLet file content cannot be null");

	// Strip comments
	content = stripComments(content.trim());
	content = convertToUpperCase(content);

	ArrayList mlets = parseMLets(content);
	if (mlets.size() < 1) throw new MLetParseException("MLet file is empty");

	ArrayList mletTags = new ArrayList();
	for (int i = 0; i < mlets.size(); ++i)
	{
	String mletTag = (String)mlets.get(i);

	MLetTag tag = parseMLet(mletTag);
	mletTags.add(tag);
	}

	return mletTags;
	}

	private MLetTag parseMLet(String content) throws MLetParseException
	{
	MLetTag tag = new MLetTag();
	parseMLetAttributes(tag, content);
	parseMLetArguments(tag, content);
	return tag;
	}

	private ArrayList parseMLets(String content) throws MLetParseException
	{
	ArrayList list = new ArrayList();
	int start = 0;
	int current = -1;
	while ((current = findOpenTag(content, start, MLET_TAG)) >= 0)
	{
	int end = findCloseTag(content, current + 1, MLET_TAG, true);
	if (end < 0) throw new MLetParseException("MLET tag not closed at index: " + current);

	String mlet = content.substring(current, end);
	list.add(mlet);

	start = end + 1;
	}
	return list;
	}

	private void parseMLetArguments(MLetTag tag, String content) throws MLetParseException
	{
	int start = 0;
	int current = -1;
	while ((current = findOpenTag(content, start, ARG_TAG)) >= 0)
	{
	int end = findCloseTag(content, current + 1, ARG_TAG, false);
	if (end < 0) throw new MLetParseException("ARG tag not closed");

	String arg = content.substring(current, end);

	int type = arg.indexOf(TYPE_ATTR);
	if (type < 0) throw new MLetParseException("Missing TYPE attribute");

	int value = arg.indexOf(VALUE_ATTR);
	if (value < 0) throw new MLetParseException("Missing VALUE attribute");

	String className = findAttributeValue(arg, type, TYPE_ATTR);
	tag.addArg(className, convertToObject(className, findAttributeValue(arg, value, VALUE_ATTR)));

	start = end + 1;
	}
	}

	private void parseMLetAttributes(MLetTag tag, String content) throws MLetParseException
	{
	int end = content.indexOf(CLOSE_BRACKET);
	String attributes = content.substring(0, end);

	// Find mandatory attributes
	int archive = -1;
	int object = -1;
	int code = -1;

	archive = attributes.indexOf(ARCHIVE_ATTR);
	if (archive < 0) throw new MLetParseException("Missing ARCHIVE attribute");

	code = attributes.indexOf(CODE_ATTR);
	object = attributes.indexOf(OBJECT_ATTR);
	if (code < 0 && object < 0) throw new MLetParseException("Missing CODE or OBJECT attribute");
	if (code > 0 && object > 0) throw new MLetParseException("CODE and OBJECT attributes cannot be both present");

	if (code >= 0)
	tag.setCode(findAttributeValue(attributes, code, CODE_ATTR));
	else
	tag.setObject(findAttributeValue(attributes, object, OBJECT_ATTR));

	tag.setArchive(findAttributeValue(attributes, archive, ARCHIVE_ATTR));

	// Look for optional attributes
	int codebase = attributes.indexOf(CODEBASE_ATTR);
	if (codebase >= 0) tag.setCodeBase(findAttributeValue(attributes, codebase, CODEBASE_ATTR));

	int name = attributes.indexOf(NAME_ATTR);
	if (name >= 0)
	{
	String objectName = findAttributeValue(attributes, name, NAME_ATTR);
	try
	{
	tag.setName(new ObjectName(objectName));
	}
	catch (MalformedObjectNameException x)
	{
	throw new MLetParseException("Invalid ObjectName: " + objectName);
	}
	}

	int version = attributes.indexOf(VERSION_ATTR);
	if (version >= 0) tag.setVersion(findAttributeValue(attributes, version, VERSION_ATTR));
	}

	private String findAttributeValue(String content, int start, String attribute) throws MLetParseException
	{
	int equal = content.indexOf('=', start);
	if (equal < 0) throw new MLetParseException("Missing '=' for attribute");

	// Ensure no garbage
	if (!attribute.equals(content.substring(start, equal).trim())) throw new MLetParseException("Invalid attribute");

	int begin = content.indexOf('"', equal + 1);
	if (begin < 0) throw new MLetParseException("Missing quotes for attribute value");

	// Ensure no garbage
	if (content.substring(equal + 1, begin).trim().length() != 0) throw new MLetParseException("Invalid attribute value");

	int end = content.indexOf('"', begin + 1);
	if (end < 0) throw new MLetParseException("Missing quote for attribute value");

	return content.substring(begin + 1, end).trim();
	}

	private int findOpenTag(String content, int start, String tag)
	{
	String opening = new StringBuffer(OPEN_BRACKET).append(tag).toString();
	return content.indexOf(opening, start);
	}

	private int findCloseTag(String content, int start, String tag, boolean strictSyntax)
	{
	int count = 1;

	do
	{
	int close = content.indexOf(CLOSE_BRACKET, start);
	if (close < 0)
	{
	return -1;
	}
	int open = content.indexOf(OPEN_BRACKET, start);
	if (open >= 0 && close > open)
	{
	++count;
	}
	else
	{
	--count;
	if (count == 0)
	{
	// Either I found the closing bracket of the open tag,
	// or the closing tag
	if (!strictSyntax \|\| (strictSyntax && content.charAt(close - 1) == '/'))
	{
	// Found the closing tag
	return close + 1;
	}
	else
	{
	// Found the closing bracket of the open tag, go for the full closing tag
	String closing = new StringBuffer(OPEN_BRACKET).append("/").append(tag).append(CLOSE_BRACKET).toString();
	close = content.indexOf(closing, start);
	if (close < 0)
	return -1;
	else
	return close + closing.length();
	}
	}
	}

	start = close + 1;
	}
	while (true);
	}

	private String stripComments(String content) throws MLetParseException
	{
	StringBuffer buffer = new StringBuffer();
	int start = 0;
	int current = -1;
	while ((current = content.indexOf(OPEN_COMMENT, start)) >= 0)
	{
	int end = content.indexOf(CLOSE_COMMENT, current + 1);

	if (end < 0) throw new MLetParseException("Missing close comment tag at index: " + current);

	String stripped = content.substring(start, current);
	buffer.append(stripped);
	start = end + CLOSE_COMMENT.length();
	}
	String stripped = content.substring(start, content.length());
	buffer.append(stripped);
	return buffer.toString();
	}

	private String convertToUpperCase(String content) throws MLetParseException
	{
	StringBuffer buffer = new StringBuffer();
	int start = 0;
	int current = -1;
	while ((current = content.indexOf("\"", start)) >= 0)
	{
	int end = content.indexOf("\"", current + 1);

	if (end < 0) throw new MLetParseException("Missing closing quote at index: " + current);

	String converted = content.substring(start, current).toUpperCase();
	buffer.append(converted);
	String quoted = content.substring(current, end + 1);
	buffer.append(quoted);
	start = end + 1;
	}
	String converted = content.substring(start, content.length()).toUpperCase();
	buffer.append(converted);
	return buffer.toString();
	}

	private Object convertToObject(String clsName, String value) throws MLetParseException
	{
	try
	{
	if (clsName.equals("boolean") \|\| clsName.equals("java.lang.Boolean"))
	return Boolean.valueOf(value);
	else if (clsName.equals("byte") \|\| clsName.equals("java.lang.Byte"))
	return Byte.valueOf(value);
	else if (clsName.equals("char") \|\| clsName.equals("java.lang.Character"))
	{
	char ch = 0;
	if (value.length() > 0) ch = value.charAt(0);
	return new Character(ch);
	}
	else if (clsName.equals("short") \|\| clsName.equals("java.lang.Short"))
	return Short.valueOf(value);
	else if (clsName.equals("int") \|\| clsName.equals("java.lang.Integer"))
	return Integer.valueOf(value);
	else if (clsName.equals("long") \|\| clsName.equals("java.lang.Long"))
	return Long.valueOf(value);
	else if (clsName.equals("float") \|\| clsName.equals("java.lang.Float"))
	return Float.valueOf(value);
	else if (clsName.equals("double") \|\| clsName.equals("java.lang.Double"))
	return Double.valueOf(value);
	else if (clsName.equals("java.lang.String"))
	return value;
	else if (mlet != null)
	{
	try
	{
	Class cls = mlet.loadClass(clsName);
	Constructor ctor = cls.getConstructor(new Class[]{String.class});
	return ctor.newInstance(new Object[]{value});
	}
	catch (Exception ignored)
	{
	}
	}
	}
	catch (NumberFormatException x)
	{
	throw new MLetParseException("Invalid value: " + value);
	}
	return null;
	}
	}