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

0

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.

0
  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?
0

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

0

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

1

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...

0

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

0

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??

0

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?

0

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

0

A gdybyś zrobił Clean & Build? :)

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0