Błąd "Exception in thread "main" java.lang.VerifyError"

Witam wszystkich.
Wziąłem się ostatnio za naukę Javy i chciałem sobie przepisać z PHP swoją klasę. Niby wszystko udało mi się przepisać ale pojawia się pewien problem. Otóż:

Exception in thread "main" java.lang.VerifyError: Inconsistent stackmap frames at branch target 486 in method MExp.count(Ljava/util/ArrayList;)D at offset 57
	at Main.main(Main.java:15)

Z informacji tu zawartych to w Main.java znajduje się:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.ArrayList;

public class Main {
	private static PrintStream out = System.out;
	private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	
	public static void main(String [] args) throws IOException{
		Main.out.println("Podaj math expression:");
		String str;
		str = Main.in.readLine();
		MExp mexp = new MExp(str);
		ArrayList<Tokens> tokens = mexp.addVar("t", Double.valueOf(512)).lexer();
		
		if(mexp.syntax_checker(tokens) == null){
			Main.out.println(mexp.errstr());
		}
		else if(!mexp.reverse_polish_notation(tokens)){
			Main.out.println(mexp.errstr());
		}
		else{
			Main.out.println(mexp._tokens.toString());
			Main.out.println(mexp._rpn.toString());
		}
	}
}

Natomiast metoda do której się czepia:

public double countExp(ArrayList<String> rpn){
		Stack<String> stack = new Stack<String>();
		for(int x = 0; x< rpn.size(); x++){
			String v = rpn.get(x);
			double a,b;
			if(MExp.isDouble(v)){
				stack.add(v);
			}
			else if(Ctype.isPunct(v)){
				switch(v){
				case "*":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf( a * b ));
				break;
				case "^":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf(Math.pow(a, b)));
				break;
				case "/":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf( a / b));
				break;
				case "+":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf( a + b ));
				break;
				case "-":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf( a - b ));
				break;
				case "%":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf(this.mod(a, b)));
				break;
				case "!":
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf(this.factorial(a)));
				break;
				}
			}
			else if(Ctype.isAlnum(v)){
				a = Double.parseDouble(stack.pop());
				stack.add(String.valueOf(MExp.call_math_function(v, a)));
			}
		}
		return this.result = Double.valueOf(stack.pop());
	}

Zaznaczam że dopiero zaczynam swoją przygodę z Javą i nie mam żadnego pomysłu o co może chodzić Eclipse'owi w tym miejscu.
Z góry dzięki za pomoc.

1. To nie Eclipse się czepia, tylko JVM.
2. Fragment dokumentacji klasy VeryfyError Thrown when the "verifier" detects that a class file, though well formed, contains some sort of internal inconsistency or security problem.
3. Skąd masz klasę MExp?

Własna klasa przepisywana z PHP.
tzn że klasa gdzieś uprawnienia przekracza??
Jak ten błąd można naprawić??

Nie ma nikt pomysłu jak temu mogę zaradzić? Przeszukałem już sporo w necie informacji i dalej jestem ciemny;P

Kod wygląda koszmarnie więc się nie dziw że nikt tego tykać nie będzie. Moja rada? Skasuj to czym prędzej i napisz jeszcze raz, od nowa, porządnie. Będzie działać. Jakbyś chociaż wstawił kompletny kod, tak ze możnaby to puścić pod debugerem to kto wie, moze by się ktoś tym zajął. A tak to wiesz...

Jakim JDK kompilujesz?
W jakim JRE uruchamiasz?

Spróbuj OpenJDK 6 lub 7.

On się czepia do MExp.count(Ljava/util/ArrayList;)D , nie do MExp.countExp(Ljava/util/ArrayList;)D

Całość piszę w Eclipse IDE for Java Developers, i z tego co znalazłem jre 7. Tak apropos całości kodu. Wygląda on w ten sposób:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;


class Tokens{
	public int position;
	public int type;
	public String value = "";
	public Tokens(int position, int type, String value) {
		this.position = position;
		this.type = type;
		this.value = value;
	}
	public String toString(){
		return String.valueOf(value);
	}
}

public class MExp {

	private String _input = "";
	public ArrayList<Tokens> _tokens = new ArrayList<Tokens>();
	public ArrayList<String> _rpn = new ArrayList<String>();
	private Map<String,Double> _vars = new HashMap<String,Double>();
	{	
		_vars.put("pi",new Double(Math.PI));
		_vars.put("e",new Double(Math.E));
	}
	
	/**
     * @var error - tablica opisująca ostatni błąd składniowy w wyrażeniu
     * 
     */ 
    public Map<String,Object> error = new HashMap<String,Object>();
    {
    	error.put("nr",new Integer(0));
    	error.put("position",new Integer(0));
    	error.put("value",new String(""));
    	error.put("expected",new String(""));
    }
    
	public double result = 0;
	//private int position;
	
	static private Map<String,String> _errstr = new HashMap<String,String>();
	{
		_errstr.put("invalid_opr","%s\n%s\nSYNTAX ERROR: Invalid operator '%s' at position '%d'\n");
		_errstr.put("invalid_var","%s\n%s\nSYNTAX ERROR: Undefined variable '%s' at position '%d'\n");
		_errstr.put("invalid_number","%s\n%s\nSYNTAX ERROR: Invalid number format '%s' at position '%d'\n");
		_errstr.put("unexpected_char","%s\n%s\nSYNTAX ERROR: Unexpected '%s' at position '%d'. Expecting '%s'\n");
		_errstr.put("unexpected_end","%s\n%s\nSYNTAX ERROR: Unexpected 'END_OF_EXPRESSION'. Expecting '%s'\n");
		
	};
	
	static private Map<String,String> _union = new HashMap<String,String>();
	{
		_union.put("]", "[");
		_union.put(")", "(");
	}
	
	static private Map<String,String> _union2 = new HashMap<String,String>();
	{
		_union.put( "[" , "]" );
		_union.put( "(" , ")" );
	}
	
	
	static private String[] _valid_operators = {
		    "/",
		    "!",
		    "*",
		    "-",
		    "+",
		    "(",
		    ")",
		    "[",
		    "]",
		    "|",
		    "^",
		    "%"
		    };
	
	static private String[] _function_lists = {
		    "abs",
		    "acos",
		    "asin",
		    "atan",
		    "cbrt",
		    "ceil",
		    "cos",
		    "cosh",
		    "exp",
		    "expm1",
		    "floor",
		    "log10",
		    "log",
		    "log1p",
		    "rint",
		    "round",
		    "signum",
		    "sin",
		    "sinh",
		    "sqrt",
		    "tan",
		    "tanh",
		    "ulp"
	};
	static int ME_NUM=1;
	static int ME_STR=2;
	static int ME_OPR=4;
	static int ME_FUN=8;
	
	MExp(String exp){
		this._input = exp.replace(" ", "");
	}
	
	MExp(String exp , Map<String,Double> vars){
		this._input=exp.replace(" ", "");
		if(vars.isEmpty()!=true)
			this._vars.putAll(vars);
	}
	
	public MExp addVar(String name,double value){
        this._vars.put(name, Double.valueOf(value));
        return this;
    }
	
	public String result(int scale){
		this.lexer();
		if(this.syntax_checker(_tokens) == null) return this.errstr();
	    if(!this.reverse_polish_notation(_tokens)) return this.errstr();
	    //this.countExp(_rpn);
	    return String.format("%." + scale + "f",this.result);
	}
	
	public static String repeat(String s, int times) {
		if (times <= 0) return "";
	    else if (times % 2 == 0) return repeat(s+s, times/2);
	    else return s + repeat(s+s, times/2);
	}
	
	public ArrayList<Tokens> lexer(){
		String str = this._input;
		ArrayList<Tokens> out = new ArrayList<Tokens>();
		char v;
		String tmp = "";
		Tokens token;
		for(int x = 0; x < str.length(); x++){
			v = str.charAt(x);
			if(Ctype.isPunct(v) && v != '_'){
				token = new Tokens( x, MExp.ME_OPR, String.valueOf(v));
				out.add(token);
			}
			else if(Ctype.isDigit(v)){
				tmp = String.valueOf(v);
				token = new Tokens( x, MExp.ME_NUM ,"");
				for(;(x+1 < str.length()) && (Ctype.isDigit(str.charAt(x+1)) || str.charAt(x+1) == 'e' || str.charAt(x+1) == 'E' || str.charAt(x+1) == '.') ; ){
					tmp += String.valueOf( str.charAt( ++x ) );
				}
				token.value = tmp;
				out.add(token);
			}
			else if(Ctype.isAlpha(v) || v == '_'){
				tmp = String.valueOf(v);
				token = new Tokens( x, MExp.ME_STR ,tmp);
				for(;((x+1 < str.length()) && (Ctype.isAlnum(str.charAt(x+1)) || str.charAt(x+1) == '_' ));){
					tmp += String.valueOf(str.charAt(++x));
				}
				token.value = tmp;
				out.add(token);
			}
		}
		return _tokens = out;
	}
	
	public ArrayList<Tokens> syntax_checker(ArrayList<Tokens> tokens){
		for(int x=0; x < tokens.size(); x++){
			if(((tokens.get(x).type==MExp.ME_OPR) && (Arrays.binarySearch(MExp._valid_operators, tokens.get(x).value))==-1)){
				this.error(0x01, tokens.get(x).position, tokens.get(x).value, "");
				return null;
			}
			else if(tokens.get(x).type==MExp.ME_STR){
				System.out.println(tokens.get(x));
				if( (tokens.size() <= x+1) || (tokens.size() > x+1 && (tokens.get(x+1).value.compareTo("(") != 0 && tokens.get(x+1).value.compareTo("[") != 0 && tokens.get(x+1).value.compareTo("|") != 0 ))){
					tokens.get(x).type=MExp.ME_NUM;
					Double y;
					y = this._vars.get(tokens.get(x).value);
					if(y != null){
						tokens.get(x).value=y.toString();
					}
					else{
						this.error(0x03, tokens.get(x).position, tokens.get(x).value, "");
						return null;
					}
				}
				else{
					tokens.get(x).type=MExp.ME_FUN;
					if(!MExp.function_exists(tokens.get(x).value)){
						this.error(0x04, tokens.get(x).position, tokens.get(x).value, "");
						return null;
					}
				}
			}	
		}
		return _tokens = tokens;
	}
	
	public boolean reverse_polish_notation(ArrayList<Tokens> tokens){
		Stack<String> stack = new Stack<String>();
		_tokens = tokens;
		int[] level = {0,0,0};
		Tokens v;
		String tmp = "";
		int i = 0;
		String r = "";
		for(int x=0; x < this._tokens.size(); x++){
			v = this._tokens.get(x);
			if(v.type == MExp.ME_NUM){
				this._rpn.add(v.value);
			}
			else if(v.type == MExp.ME_OPR){
				if(v.value.compareTo("[") == 0 || v.value.compareTo("(") == 0){
					stack.add(v.value);
					level[MExp.btype(v.value)]++;
				}
				else if(v.value.compareTo("]") == 0||v.value.compareTo(")") == 0){
					if(level[MExp.btype(MExp._union.get(v.value))] == 0){
						this.error(0x11, v.position, v.value, "");
						return false;
					}
					else{
						if(level[MExp.btype("(")] == level[MExp.btype("[")])tmp = "-1";
						tmp = (tmp.length() == 0 ? (level[MExp.btype("(")] > level[MExp.btype("[")]?"(":"[") : tmp);
						switch(tmp){
						case "(":
							i = stack.size();
							r = stack.get(--i);
							while((r != "(" || r != "[") && i > 0){
								r = stack.get(--i);
							}
							if(r == MExp._union.get(v.value)){
								String last = stack.pop();
								while(last != r ^ last != null){
									this._rpn.add(last);
									if(!stack.isEmpty()) 
										last = stack.pop();
									else
										last = null;
								}
								level[MExp.btype(r)]--;
							}
							else if(MExp._union.get(v.value) != tmp){
								this.error(0x12, v.position, v.value, MExp._union2.get(tmp));
								return false;
							}
							else{
								String last = stack.pop();
								while(last != tmp ^ last != null){
									this._rpn.add(last);
									if(!stack.isEmpty()) 
										last = stack.pop();
									else
										last = null;
								}
								level[MExp.btype(tmp)]--;
							}
						break;
						case "[":
							i = stack.size();
							r = stack.get(--i);
							while(r != "(" || r != "["){
								r = stack.get(--i);
							}
							if(r == MExp._union.get(v.value)){
								String last = stack.pop();
								while(last != r ^ last != null){
									this._rpn.add(last);
									if(!stack.isEmpty()) 
										last = stack.pop();
									else
										last = null;
								}
								level[MExp.btype(r)]--;
							}
							else if(MExp._union.get(v.value) != tmp){
								this.error(0x13, v.position, v.value, MExp._union2.get(tmp));
								return false;
							}
							else{
								String last = stack.pop();
								while(last != tmp ^ last != null){
									this._rpn.add(last);
									if(!stack.isEmpty()) 
										last = stack.pop();
									else
										last = null;
								}
								level[MExp.btype(tmp)]--;
							}
						break;
						case "-1":
							i = stack.size();
							r = stack.get(--i);
							while(r != "(" || r != "["){
								r = stack.get(--i);
							}
							if(r == MExp._union.get(v.value)){
								String last = stack.pop();
								while(last != r ^ last != null){
									this._rpn.add(last);
									if(!stack.isEmpty()) 
										last = stack.pop();
									else
										last = null;
								}
								level[MExp.btype(r)]--;
							}
							else{
								this.error(0x14, v.position, v.value, MExp._union2.get(r));
								return false;
							}
						break;
						}
					}
				}
				else{
					if(v.value.compareTo("-") == 0 && (x-1 < 0 || tokens.get(x-1).type == MExp.ME_OPR)) this._rpn.add("0");
					int pr = MExp.operator_priority(v.value);
					String last;
					if(!stack.isEmpty()) 
						last = stack.pop();
					else
						last = null;
					if(last == null){
						stack.add(v.value);
					}
					else if(pr >= MExp.operator_priority(last)){
						stack.add(last);
						stack.add(v.value);
					}
					else if(last.compareTo("(") == 0 || last.compareTo("[") == 0){
						stack.add(last);
						stack.add(v.value);
					}
					else{
						if(last != null && last != "") 
							this._rpn.add(last);
						while(last != null && pr > MExp.operator_priority(last)){
							this._rpn.add(last);
							if(!stack.isEmpty()) 
								last = stack.pop();
							else
								last = null;
						}
						stack.add(v.value);
					}
				}
			}
			else if(v.type == MExp.ME_FUN){
				if(v.value.compareTo("-") == 0  && (x-1 < 0 || tokens.get(x-1).type == MExp.ME_OPR)) this._rpn.add("0");
				int pr = MExp.operator_priority(v.value);
				String last = stack.isEmpty() ? null : stack.pop();
				if(last == null){
					stack.add(v.value);
				}
				else if(pr >= MExp.operator_priority(last)){
					stack.add(last);
					stack.add(v.value);
				}
				else if(last == "(" || last == "["){
					stack.add(last);
					stack.add(v.value);
				}
				else{
					this._rpn.add(last);
					while(last != null && pr > MExp.operator_priority(last)){
						this._rpn.add(last);
						last = stack.pop();
					}
					stack.add(v.value);
				}
			}
			/*/ dev info       
	        System.out.println("wejście: \t" + v.value);
	        System.out.println("level1: \t" + level[0]);
	        System.out.println("level2: \t" + level[1]);
	        System.out.println("stos: \t\t" + stack.toString());
	        System.out.println("wyjście: \t"+ _rpn.toString() + "\n");
	         // dev info - end*/
		}
		if(level[0] != 0 || level[1] != 0){
			i = stack.size();
			r = stack.get(--i);
			while((r != "(" || r!= "[") && i > 0){
				r = stack.get(--i);
			}
			this.error(0x15, this._input.length(), "END_OF_EXPRESSION", MExp._union2.get(r));
			return false;
		}
		while(!stack.isEmpty())
			this._rpn.add(stack.pop());
		return true;
	}
	
	private static boolean function_exists(String name){
		return Arrays.binarySearch(MExp._function_lists, name)!=-1?true:false;
	}
	private static int btype(String bracket){
		int r;
		switch(bracket){
			case "(": r = 0; break;
			case "[": r = 1; break;
			case "|": r = 2; break;
			default : r = -1; break;
		};
		return r;
	}
	public String replaceAt(int i,String s,char c){
		char[] o;
		o = s.toCharArray();
		o[i] = c;
		return String.valueOf(o);
 	}
	public void error(int nr, int position, String value,String expected){
    	error.put("nr",new Integer(nr));
    	error.put("position",new Integer(position));
    	error.put("value",value);
    	error.put("expected",expected);
    }
	public String errstr(){
		String space;
		space = replaceAt(Integer.parseInt(this.error.get("position").toString()),MExp.repeat(" ",this._input.length()+1),'|');
        
        String ret = "";
		switch(Integer.parseInt(this.error.get("nr").toString())){
		case 0x00:
			ret = "OK";
		break;
		case 0x01:
			ret = String.format(MExp._errstr.get("invalid_opr"), this._input, String.valueOf(space), this.error.get("value"), Integer.parseInt(this.error.get("position").toString())+1);
        break;
        case 0x02:
        	ret = String.format(MExp._errstr.get("invalid_number"), this._input, String.valueOf(space), this.error.get("value"), Integer.parseInt(this.error.get("position").toString())+1);
        break;
        case 0x03:
        	ret = String.format(MExp._errstr.get("invalid_var"), this._input, String.valueOf(space), this.error.get("value"), Integer.parseInt(this.error.get("position").toString())+1);
        break;
        case 0x04:
        	ret = String.format(MExp._errstr.get("invalid_fun"), this._input, String.valueOf(space), this.error.get("value"), Integer.parseInt(this.error.get("position").toString())+1);
        break;
        case 0x11:
        case 0x12:
        case 0x13:
        case 0x14:
        	ret = String.format(MExp._errstr.get("unexpected_char"), this._input, String.valueOf(space), this.error.get("value"), Integer.parseInt(this.error.get("position").toString())+1,this.error.get("expected"));
        break;
        case 0x15:
        	ret = String.format(MExp._errstr.get("unexpected_end"), this._input, String.valueOf(space),this.error.get("expected"));
        break;
		}
		return ret;
	}
	
	private static int operator_priority(String value){
		switch(value){
		case "": return -1;
		case "[":return -1;
        case "(":return -1;
        case "+":return 0;
        case "-":return 0;
        case "*":return 1;
        case "/":return 1;
        case "%":return 2;
        case "^":return 2;
        case "!":return 3;
        default: return 256;
		}
	}
	
	private double mod(double x, double mod)
    {
    	double i = Math.floor( x / mod );
    	double x2 = i * mod;
    	return x - x2;
    }
	private double factorial(double n){
		n = Math.abs( Math.floor(n) );
        if( n==0 || n==1)
            return 1;
        return  n * factorial( n - 1 );
    }
	private static boolean isDouble(String str){
		try{
			Double.parseDouble(str);
			return true;
		}
		catch (Exception e){
			return false;
		}
	}
	public static Double call_math_function(String name, Double param){
		Double ret = null;
		switch(name){
		case "abs": ret = new Double(Math.abs(param.doubleValue())); break;
		case "acos": ret = new Double(Math.acos(param.doubleValue())); break;
		case "asin": ret = new Double(Math.asin(param.doubleValue())); break;
		case "atan": ret = new Double(Math.atan(param.doubleValue())); break;
		case "cbrt": ret = new Double(Math.cbrt(param.doubleValue())); break;
		case "ceil": ret = new Double(Math.ceil(param.doubleValue())); break;
		case "cos": ret = new Double(Math.cos(param.doubleValue())); break;
		case "cosh": ret = new Double(Math.cosh(param.doubleValue())); break;
		case "exp": ret = new Double(Math.exp(param.doubleValue())); break;
		case "expm1": ret = new Double(Math.expm1(param.doubleValue())); break;
		case "floor": ret = new Double(Math.floor(param.doubleValue())); break;
		case "log10": ret = new Double(Math.log10(param.doubleValue())); break;
		case "log": ret = new Double(Math.log(param.doubleValue())); break;
		case "log1p": ret = new Double(Math.log1p(param.doubleValue())); break;
		case "rint": ret = new Double(Math.rint(param.doubleValue())); break;
		case "round": ret = new Double(Math.round(param.doubleValue())); break;
		case "signum": ret = new Double(Math.signum(param.doubleValue())); break;
		case "sin": ret = new Double(Math.sin(param.doubleValue())); break;
		case "sinh": ret = new Double(Math.sinh(param.doubleValue())); break;
		case "sqrt": ret = new Double(Math.sqrt(param.doubleValue())); break;
		case "tan": ret = new Double(Math.tan(param.doubleValue())); break;
		case "tanh": ret = new Double(Math.tanh(param.doubleValue())); break;
		case "ulp": ret = new Double(Math.ulp(param.doubleValue())); break;
		}
		return ret;
	}
	public double countExp(ArrayList<String> rpn){
		Stack<String> stack = new Stack<String>();
		for(int x = 0; x< rpn.size(); x++){
			String v = rpn.get(x);
			double a,b;
			if(MExp.isDouble(v)){
				stack.add(v);
			}
			else if(Ctype.isPunct(v)){
				switch(v){
				case "*":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf( a * b ));
				break;
				case "^":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf(Math.pow(a, b)));
				break;
				case "/":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf( a / b));
				break;
				case "+":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf( a + b ));
				break;
				case "-":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf( a - b ));
				break;
				case "%":
					b = Double.parseDouble(stack.pop());
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf(this.mod(a, b)));
				break;
				case "!":
					a = Double.parseDouble(stack.pop());
					stack.add(String.valueOf(this.factorial(a)));
				break;
				}
			}
			else if(Ctype.isAlnum(v)){
				a = Double.parseDouble(stack.pop());
				stack.add(String.valueOf(MExp.call_math_function(v, a)));
			}
		}
		this.result = Double.parseDouble(stack.pop());
		return 0;
	}
}

I to jest własnie owa klasa, do tego jeszcze używana wewnątrz klasa :

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Ctype {
	final static boolean isLower(String str){
		Pattern a = Pattern.compile("\\p{Lower}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isUpper(String str){
		Pattern a = Pattern.compile("\\p{Upper}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isAlpha(String str){
		Pattern a = Pattern.compile(".*\\p{Alpha}");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isPunct(String str){
		Pattern a = Pattern.compile("\\p{Punct}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isGraph(String str){
		Pattern a = Pattern.compile("\\p{Graph}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isDigit(String str){
		Pattern a = Pattern.compile("\\p{Digit}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isPrint(String str){
		Pattern a = Pattern.compile("\\p{Print}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isAlnum(String str){
		Pattern a = Pattern.compile("\\p{Alnum}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	
	final static boolean isCntrl(String str){
		Pattern a = Pattern.compile("\\p{Cntrl}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isSpace(String str){
		Pattern a = Pattern.compile("\\p{Space}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isBlank(String str){
		Pattern a = Pattern.compile("\\p{Blank}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isXDigit(String str){
		Pattern a = Pattern.compile("\\p{XDigit}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	final static boolean isASCII(String str){
		Pattern a = Pattern.compile("\\p{ASCII}*");
		Matcher m = a.matcher(str);
		return m.matches();
	}
	
	/* For Char type */
	
	final static boolean isLower(char str){
		Pattern a = Pattern.compile("\\p{Lower}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isUpper(char str){
		Pattern a = Pattern.compile("\\p{Upper}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isAlpha(char str){
		Pattern a = Pattern.compile(".*\\p{Alpha}");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isPunct(char str){
		Pattern a = Pattern.compile("\\p{Punct}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isGraph(char str){
		Pattern a = Pattern.compile("\\p{Graph}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isDigit(char str){
		Pattern a = Pattern.compile("\\p{Digit}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isPrint(char str){
		Pattern a = Pattern.compile("\\p{Print}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isAlnum(char str){
		Pattern a = Pattern.compile("\\p{Alnum}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	
	final static boolean isCntrl(char str){
		Pattern a = Pattern.compile("\\p{Cntrl}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isSpace(char str){
		Pattern a = Pattern.compile("\\p{Space}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isBlank(char str){
		Pattern a = Pattern.compile("\\p{Blank}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isXDigit(char str){
		Pattern a = Pattern.compile("\\p{XDigit}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
	final static boolean isASCII(char str){
		Pattern a = Pattern.compile("\\p{ASCII}*");
		Matcher m = a.matcher(String.valueOf(str));
		return m.matches();
	}
}

a main służy na razie tylko do testowania klasy. Z analizy to wszystko w klasie działa mi zgodnie z moimi założeniami aż do momentu własnie owej felernej metody countExp() (sorki za różnice nazw ale poprzednia jej nazwa to własnie count()) zresztą możecie sobie sprawdzić biorąc w komentarz tą metodę i wpisać np: "sin(pi)*cos(pi)"

Nie rozumiem co takiego strasznego jest w tym kodzie??

Eclipse ma swój kompilator i może to jego wina... googlnąłem trochę i znalazłem bug ticket
https://bugs.eclipse.org/bugs/show_bug.cgi?id=356002 - to jest na wersję Eclipsa 3.7.0-1
Ja mam 3.7.2 i nie występuje u mnie ten problem. Jaką masz wersję Eclipsa?

no właśnie mam wersję 3.7.2.M20120208-0800. W tamtym tygodniu ściągałem ze oficjalnej stronki.

A gdybyś zrobił Clean & Build? :)

Co jest źle? Za kombinacje klawiszy ctrl+c i ctrl+v powinien ci eksplodować monitor...
Wszystkie metody w klasie CType są IDENTYCZNE z dokładnością do jednego stringa. Nie uważasz że w takim razie powinna tam być jedna metoda z której wszystkie inne korzystają?
Tak samo zresztą ten countExp.
Kody błędów? Wiesz co to wyjątki?
Poza tym metody powinny mieć średnio kilkanaście linijek i realizować jedną konkretna rzecz.

Ale wracając do problemu: co sie dzieje jak uruchomisz to pod debuggerem?

A kurde coś namodziłem i nie chce mi się teraz skompilować. "Error: Could not find or load main class Main". Chwila i zaraz to ogarnę.

Już ogarnąłem. Głupi ręcznie usunąłem binarycode'y;P ale wracając do problemu to się nie rozwiązał.
Debugowanie:

Main [Java Application]	
	Main at localhost:35714	
		Thread [main] (Suspended (exception VerifyError))	
			Main.main(String[]) line: 15	
	C:\Program Files\Java\jre7\bin\javaw.exe (16-03-2012 00:54:18)	

I kolejny krok terminated.

Pisałem tamtego posta jak jeszcze nie było Twojego tasiemca...
skopiowałem go teraz do siebie i rzeczywiście wywala błąd weryfikacji....

Ale to jest wina kompilatora w Eclipse, skompilowałem ten kod przez javac i taki działa.
Prawdopodobnie chodzi o String w switchu, który jest nowy w Javie 7 i programiści Eclipse mogli coś lekko spieprzyć przy wprowadzaniu tego do swojego kompilatora. Zmniejszę go trochę do prostszej postaci i wyślę bug reporta do JDT.

Ty tymczasem możesz jedynie trochę uporządkować kod, bo swoją drogą pewnie dlatego Eclipse się pogubiło...

EDIT
Można to jeszcze obejść w inny sposób:
do eclipse, w "run configurations" w "arguments", w polu "VM Arguments" dodaj to
-XX:-UseSplitVerifier
to dla testu... a później, jeśli chcesz skompilowany program wysłać komuś,
to skompiluj go przez javac, a nie przez Eclipse..

przykładowe użycie javac w głównym katalogu projektu eclipse:

javac -cp src -d classes src/Main.java

Tak czy siak osoba ta musi mieć javę 7, żeby zadziałał program pod nią skompilowany, więc jeśli jest to zapewne wykładowca, równie dobrze może po prostu dodać powyższy parametr do runtime'u - wystarczy powiedzieć, że to problemy techniczne z Eclipsem... (z drugiej strony za taki śmieciowy kod na pewno Ci nie zaliczy)

Dzięki za pomoc. Nareszcie udało mi się sprawdzić czy działa poprawnie.
A tak przy okazji śmieciowości tego kodu. Jak go trochę ulepszyć oraz na co w przyszłości zwracać uwagę? Zrobić więcej metod które wykonują pomniejsze zadania???

PS. Robię ten kod bardziej dla siebie, aczkolwiek podobno będę miał za zadanie na Językach Programowania Obiektowego napisać liczenie wyrażeń za pomocą RPN. Tylko że prawdobodobnie w C++, więc będzie mnie jeszcze czekało przepisanie tej klasy na c++ :)

@shinuexx poczytaj sobie książkę Clean Code, bo długo by wymieniać co w tym kodzie jest nie tak. Najbardziej oczywiste rzeczy zawarłem już wyżej.
Zadaj sobie proste pytania:

• ile pracy kosztowałoby mnie dodanie nowego działania do tej aplikacji i czemu aż tyle.
• czy możesz dodać nowe działania NIE modyfikując kodu (tylko dodając nowy) i czemu nie (patrz: zasada Open-Close-Rule)
• czy ktoś "z ulicy" byłby w stanie bez problemu dodać nowe działanie do twojej aplikacji i czemu nie.