Unnamed

package com.sl.bytecode;import java.util.ArrayList;public class MethodTypeRegex implements MethodFilter{    private String return_type;    private String[] arguments;    private boolean is_static;    private static final String[] types = new String[]{"byte", "boolean", "char", "short", "int", "float", "long", "double", "void"};    private static final String[] signatures = new String[]{"B", "Z", "C", "S", "I", "F", "J", "D", "V", "L*;"};    public MethodTypeRegex(String methodtype, String methodargs, boolean stat){        return_type = new Type(methodtype).toSignature();        parseArgs(methodargs);        is_static = stat;    }    private void parseArgs(String args){        SpecialString s = new SpecialString(args);        ArrayList<String> inttypes = s.deleteAll("byte");        inttypes.addAll(s.deleteAll("char"));        inttypes.addAll(s.deleteAll("short"));        inttypes.addAll(s.deleteAll("int"));        ArrayList<String> bools = s.deleteAll("boolean");        ArrayList<String> floats = s.deleteAll("float");        ArrayList<String> longs = s.deleteAll("long");        ArrayList<String> doubles = s.deleteAll("double");        String remaining = s.toString();        ArrayList<String> objects = new ArrayList<String>();        String[] sts = remaining.split(",");        for(String st : sts)            objects.add("L"+st.replaceAll(".", "/")+";");        arguments = new String[inttypes.size() + bools.size() + floats.size() + longs.size() + doubles.size() + objects.size()];        int overallindex = 0;        for(int i = 0; i < inttypes.size(); i++){            arguments[overallindex] = "I";            overallindex++;        }        for(int i = 0; i < bools.size(); i++){            arguments[overallindex] = "Z";            overallindex++;        }        for(int i = 0; i < floats.size(); i++){            arguments[overallindex] = "F";            overallindex++;        }        for(int i = 0; i < longs.size(); i++){            arguments[overallindex] = "J";            overallindex++;        }        for(int i = 0; i < doubles.size(); i++){            arguments[overallindex] = "D";            overallindex++;        }        for(int i = 0; i < objects.size(); i++){            arguments[overallindex] = "L"+objects.get(i).replaceAll(".", "/")+";";            overallindex++;        }    }    private class SpecialString{        private static final boolean debug = true;        private char[] characters;        public SpecialString(String s){            this.characters = s.toCharArray();        }        public char deleteAt(int index){            char[] cs = new char[characters.length - 1];            char c = characters[index];            System.arraycopy(characters, 0, cs, 0, index);            System.arraycopy(characters, index + 1, cs, index, cs.length - index);            return c;        }        public char deleteNext(char c){            for(int i = 0; i < characters.length; i++){                if(characters[i] == c)                    return deleteAt(i);            }            return '!';        }        public char[] delete(int start, int length){            char[] c = new char[length];            for(int i = 0; i < length; i++){                c[i] = deleteAt(start + i);            }            return c;        }        public ArrayList<String> deleteAll(String pattern){            String s = new String(characters);            ArrayList<String> a = new ArrayList<String>();            int index;            int end;            String temp;            char endchar = pattern.charAt(pattern.length() - 1);            while((index = s.indexOf(pattern)) != -1){                end = s.substring(index + 1).indexOf(endchar) + index + 1;                String s1 = s.substring(0, index);                String s2 = s.substring(end + 1);                s = s1 + s2;                characters = s.toCharArray();                a.add(pattern);            }            return a;        }        public void delete(String s){            String c = new String(characters);            int index = c.indexOf(s);            String s1 = c.substring(0, index);            String s2 = c.substring(index + s.length());            characters = (s1 + s2).toCharArray();        }        public boolean hasSequence(String s){            return indexOf(s) != -1;        }        public int indexOf(String s){            return new String(characters).indexOf(s);        }        public void appendString(String s){            characters = (new String(characters) + s).toCharArray();        }        public int size(){            return characters.length;        }        public String toString(){            return new String(characters);        }    }    private static final StaticFilter sf = new StaticFilter();    public boolean accept(Method m){        if((is_static && !sf.accept(m)) || (!is_static && sf.accept(m)))            return false;        return accept(m.getSignature());    }    public boolean accept(String string){        SpecialString s = new SpecialString(string);        String ret = string.substring(string.indexOf(")") + 1, string.length());        if(!ret.equals(return_type)){            //System.out.println("wrong type");            return false;        }        for(String st : arguments){            System.out.println(st);            if(!s.hasSequence(st)){                if(st.equals("I")){                    if(s.hasSequence("B") || s.hasSequence("S") || s.hasSequence("C"))                        continue;                    else                        return false;                }                else{                    //System.out.println("wrong sequence: "+s+":"+st);                    return false;                }            }            s.delete(st);        }        return true;    }    public String toString(){        String s = "(";        for(String st : arguments)            s += st;        s += ")"+return_type;        return s + ":" + is_static;    }}