public StringParser(String s) 
{
        data = s;
        start = 0;
        end = s.length()-1;
}

 public char getLastChar() 
{
        char c = testLastChar();
        end--;
        return c;
}

 public float getLastFloat(int def) 
{
        return parseFloat(getLastString(), def);
}

 public int getLastInt(int def) 
{
        return parseInt(getLastString(), def);
}

 public int getLastIntUntil(String delim,
    int def) 
{
        return parseInt(getLastStringUntil(delim + WHITESPACE), def);
}

 public String getLastString() 
{
        return getLastStringUntil(WHITESPACE);
}

Returns the last non empty chars *

 public String getLastStringUntil(String delim) 
{
        skipLastEmpty();
        for(int i=end; i >=start; i--) {
            if (delim.indexOf(data.charAt(i)) >=0) {
                String s = (i< end ? data.substring(i+1, end+1) : "");
                end = i;
                return s;
            }
        }
        String s = (start< =end ? data.substring(start, end+1) : "");
        end = start-1;
        return s;
}

Returns the last non empty chars until any char in delim is met, skipping the head withespaces

 public char getNextChar() 
{
        char c = testNextChar();
        start++;
        return c;
}

 public float getNextFloat(int def) 
{
        return parseFloat(getNextString(), def);
}

 public int getNextInt(int def) 
{
        return parseInt(getNextString(), def);
}

 public int getNextIntUntil(String delim,
    int def) 
{
        return parseInt(getNextStringUntil(delim + WHITESPACE), def);
}

 public String getNextString() 
{
        return getNextStringUntil(WHITESPACE);
}

Returns the next non empty chars

 public String getNextStringUntil(String delim) 
{
        skipNextEmpty();
        for(int i=start; i< =end; i++) {
            if (delim.indexOf(data.charAt(i)) >=0) {
                String s = (i >start ? data.substring(start, i) : "");
                start = i;
                return s;
            }
        }
        String s = (start< =end ? data.substring(start, end+1) : "");
        start = end+1;
        return s;
}

Returns the next non empty chars until any char in delim is met, skipping the head withespaces

 public String getRemainingString() 
{
        skipNextEmpty();
        skipLastEmpty();
        if (start< =end) {
            return data.substring(start, end+1);
        } else {
            return "";
        }
}

 public boolean goAfter(char delim) 
{
        for(int i=start; i< =end; i++) {
            if (delim == data.charAt(i)) {
                start = i+1;
                return true;
            }
        }
        start = end+1;
        return false;
}

Skips the next chars until delim is met *

 public boolean goBefore(char delim) 
{
        for(int i=end; i >=start; i--) {
            if (delim == data.charAt(i)) {
                end = i-1;
                return true;
            }
        }
        end = start-1;
        return false;
}

Skips the next chars until delim is met *

 public boolean hasMoreData() 
{
        return start< =end;
}

 public static float parseFloat(String s,
    int def) 
{
        try {
            return Float.parseFloat(s);
        }
        catch(Exception e) {
            return def;
        }
}

Converts a String to an float, without failing *

 public static int parseInt(String s,
    int def) 
{
        try {
            return Integer.parseInt(s);
        }
        catch(Exception e) {
            return def;
        }
}

Converts a String to an int, without failing *

 public static boolean stringContainsOnly(String s,
    String chars) 
{
        int nb = s.length();
        for(int i=0; i< nb; i++) {
            if (chars.indexOf(s.charAt(i))< 0)
                return false;
        }
        return true;
}

 public char testLastChar() 
{
        skipLastEmpty();
        if (start< =end)
            return data.charAt(end);
        else
            return '\0';
}

 public char testNextChar() 
{
        skipNextEmpty();
        if (start< =end)
            return data.charAt(start);
        else
            return '\0';
}