util.java

JASML is a java byte code compiler, providing yet another approach to view, write and edit java clas

/*
 * Author jyang
 * Created on 2006-4-6 11:23:56
 */
package com.jasml.helper;

import java.util.StringTokenizer;

import com.jasml.classes.Constants;

public class Util {

	public static String accessFlagToString_Class(short accessFlag) {
		StringBuffer buf = new StringBuffer();
		if ((accessFlag & Constants.ACCESS_FLAG_CLASS_PUBLIC) != 0)
			buf.append("public ");
		if ((accessFlag & Constants.ACCESS_FLAG_CLASS_FINAL) != 0)
			buf.append("final ");
		if ((accessFlag & Constants.ACCESS_FLAG_CLASS_ABSTRACT) != 0)
			buf.append("abstract ");
		if ((accessFlag & Constants.ACCESS_FLAG_CLASS_INTERFACE) != 0)
			buf.append("interface ");
		else {
			buf.append("class ");
		}
		return buf.toString().trim();
	}

	public static short getAccessFlag_Class(String s) {
		short ret = 0x0;
		if (s.indexOf("public") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_PUBLIC);

		if (s.indexOf("final") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_FINAL);

		if (s.indexOf("abstract") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_CLASS_ABSTRACT);

		if (s.indexOf("interface") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_CLASS_INTERFACE);

		if (s.indexOf("class") != -1) {
			/**
			 * copied from jvm specification
			 * All new compilers to the instruction set of the Java virtual machine should set the ACC_SUPER flag.
			 */
			ret = (short) (ret | Constants.ACCESS_FLAG_CLASS_SUPER);
		}
		return ret;

	}

	public static String accessFlagToString_Field(short accessFlag) {
		StringBuffer buf = new StringBuffer();
		if ((accessFlag & Constants.ACCESS_FLAG_FIELD_PUBLIC) != 0)
			buf.append("public ");
		if ((accessFlag & Constants.ACCESS_FLAG_FIELD_PRIVATE) != 0)
			buf.append("private ");
		if ((accessFlag & Constants.ACCESS_FLAG_FIELD_PROTECTED) != 0)
			buf.append("protected ");
		if ((accessFlag & Constants.ACCESS_FLAG_FIELD_STATIC) != 0)
			buf.append("static ");
		if ((accessFlag & Constants.ACCESS_FLAG_FIELD_FINAL) != 0)
			buf.append("final ");
		if ((accessFlag & Constants.ACCESS_FLAG_FIELD_VOLATILE) != 0)
			buf.append("volatile ");
		if ((accessFlag & Constants.ACCESS_FLAG_FIELD_TRANSIENT) != 0)
			buf.append("transient ");
		return buf.toString().trim();
	}

	public static String accessFlagToString_Method(short accessFlag) {
		StringBuffer buf = new StringBuffer();
		if ((accessFlag & Constants.ACCESS_FLAG_METHOD_PUBLIC) != 0)
			buf.append("public ");
		if ((accessFlag & Constants.ACCESS_FLAG_METHOD_PRIVATE) != 0)
			buf.append("private ");
		if ((accessFlag & Constants.ACCESS_FLAG_METHOD_PROTECTED) != 0)
			buf.append("protected ");
		if ((accessFlag & Constants.ACCESS_FLAG_METHOD_STATIC) != 0)
			buf.append("static ");
		if ((accessFlag & Constants.ACCESS_FLAG_METHOD_FINAL) != 0)
			buf.append("final ");
		if ((accessFlag & Constants.ACCESS_FLAG_METHOD_SYNCHRONIZED) != 0)
			buf.append("synchronized ");
		if ((accessFlag & Constants.ACCESS_FLAG_METHOD_NATIVE) != 0)
			buf.append("native ");
		if ((accessFlag & Constants.ACCESS_FLAG_METHOD_ABSTRACT) != 0)
			buf.append("abstract ");
		if ((accessFlag & Constants.ACCESS_FLAG_METHOD_STRICT) != 0)
			buf.append("strictfp ");
		return buf.toString().trim();
	}

	public static short getAccessFlag_Method(String s) {
		short ret = 0x0;
		if (s.indexOf("public") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_PUBLIC);
		if (s.indexOf("private") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_PRIVATE);

		if (s.indexOf("protected") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_PROTECTED);

		if (s.indexOf("static") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_STATIC);

		if (s.indexOf("final") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_FINAL);

		if (s.indexOf("synchronized") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_SYNCHRONIZED);

		if (s.indexOf("native") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_NATIVE);

		if (s.indexOf("abstract") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_ABSTRACT);

		if (s.indexOf("strictfp") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_STRICT);
		return ret;
	}

	public static short getAccessFlag_Field(String s) {
		short ret = 0x0;
		if (s.indexOf("public") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_PUBLIC);
		if (s.indexOf("private") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_PRIVATE);

		if (s.indexOf("protected") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_PROTECTED);

		if (s.indexOf("static") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_STATIC);

		if (s.indexOf("final") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_METHOD_FINAL);

		if (s.indexOf("volatile") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_FIELD_VOLATILE);

		if (s.indexOf("transient") != -1)
			ret = (short) (ret | Constants.ACCESS_FLAG_FIELD_TRANSIENT);
		return ret;

	}

	public static boolean hasMethodBody(short accessFlag) {
		if ((accessFlag & Constants.ACCESS_FLAG_METHOD_ABSTRACT) != 0 || (accessFlag & Constants.ACCESS_FLAG_METHOD_NATIVE) != 0) {
			return false;
		} else {
			return true;
		}
	}

	public static String methodParameterToString(String paras) {
		if (paras == null || paras.trim().length() == 0) {
			return "";
		}
		StringBuffer buf = new StringBuffer();
		String brackets;
		int ti;

		for (int i = 0; i < paras.length(); i++) {
			switch (paras.charAt(i)) {
			case 'B':
				buf.append("byte");
				break;
			case 'C':
				buf.append("char");
				break;
			case 'D':
				buf.append("double");
				break;
			case 'F':
				buf.append("float");
				break;
			case 'I':
				buf.append("int");
				break;
			case 'J':
				buf.append("long");
				break;
			case 'S':
				buf.append("short");
				break;
			case 'Z':
				buf.append("boolean");
				break;
			case 'V':
				buf.append("void");
				break;
			case '[':
				brackets = "[]";
				while (paras.charAt(++i) == '[') {
					brackets = brackets + "[]";
				}
				if (paras.charAt(i) == 'L') {
					ti = paras.indexOf((int) ';', i);
					buf.append(Util.descriptorToString(paras.substring(i, ti + 1)));
					i = ti;
				} else {
					buf.append(Util.descriptorToString(Character.toString(paras.charAt(i))));
				}
				buf.append(brackets);
				break;
			case 'L':
				ti = paras.indexOf((int) ';', i);
				buf.append(Util.descriptorToString(paras.substring(i, ti + 1)));
				i = ti;
				break;
			default:
				buf.append("[unknow paras(" + paras.charAt(i) + ")]");
			}
			buf.append(",");
		}
		buf.deleteCharAt(buf.length() - 1);
		return buf.toString();
	}

	public static String descriptorToString(String type) {
		if (type == null || type.trim().length() == 0) {
			return "";
		}
		switch (type.charAt(0)) {
		case 'B':
			return "byte";
		case 'C':
			return "char";
		case 'D':
			return "double";
		case 'F':
			return "float";
		case 'I':
			return "int";
		case 'J':
			return "long";
		case 'L':
			return type.substring(1, type.length() - 1).replace('/', '.');
		case 'S':
			return "short";
		case 'Z':
			return "boolean";

		case '[':
			int dim = 1;
			String brackets = "[]";
			while (type.charAt(dim) == '[') {
				dim++;
				brackets = brackets + "[]";
			}
			return descriptorToString(type.substring(dim)) + brackets;
		case 'V':
			return "void";
		default:
			return "[unknow type(" + type + ")]";
		}
	}

	/*
	 * A type of any class must starts with 'L'
	 */
	public static String toInnerType(String normalType) {
		if (normalType == null || normalType.length() == 0)
			return "";

		String ret = "";
		int i;
		for (i = normalType.length() - 1; i >= 0; i--) {
			if (normalType.charAt(i) == '[') {
				ret = ret + "[";
			} else if (normalType.charAt(i) != ']') {
				break;
			}
		}
		normalType = normalType.substring(0, i + 1).trim();

		if (normalType.equals("byte") == true)
			ret = ret + "B";
		else if (normalType.equals("char") == true)
			ret = ret + "C";
		else if (normalType.equals("double") == true)
			ret = ret + "D";
		else if (normalType.equals("float") == true)
			ret = ret + "F";
		else if (normalType.equals("int") == true)
			ret = ret + "I";
		else if (normalType.equals("long") == true)
			ret = ret + "J";
		else if (normalType.equals("short") == true)
			ret = ret + "S";
		else if (normalType.equals("boolean") == true)
			ret = ret + "Z";
		else if (normalType.equals("void") == true)
			ret = "V";
		else
			ret = ret + "L" + normalType.replace('.', '/') + ";";
		return ret;
	}

	/*
	 * 
	 * It is used in constant_class_info structure. Can be like
	 * java.lang.Object, java.lang.Object[][], int[][]. the difference with
	 * toInnerType() is when translating java.lang.Object, the toInnerType()
	 * will get Ljava/lang/Object; while this method will get java/lang/Object.
	 */
	public static String toInnerClassName(String className) {
		int i, dim = 0;

		for (i = 0; i < className.length(); i++) {
			if (className.charAt(i) == '[')
				dim++;
		}

		i = className.indexOf('[');

		if (i != -1) {
			className = className.substring(0, i);
		} else {
			return className.replace('.', '/');
		}

		className = toInnerType(className);
		while (dim-- > 0) {
			className = "[" + className;
		}
		return className;
	}

	public static String toInnerParameterTypes(String paras) {
		if (paras == null || paras.length() == 0) {
			return "";
		}
		StringBuffer buf = new StringBuffer();
		StringTokenizer token = new StringTokenizer(paras, ",");