package com.netscape.pkisilent.argparser;

// --- BEGIN COPYRIGHT BLOCK ---
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; version 2 of the License.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// (C) 2007 Red Hat, Inc.
// All rights reserved.
// --- END COPYRIGHT BLOCK ---

/**
 * Copyright John E. Lloyd, 2004. All rights reserved. Permission to use, copy,
 * modify and redistribute is granted, provided that this copyright notice is
 * retained and the author is given credit whenever appropriate.
 * 
 * This software is distributed "as is", without any warranty, including any
 * implied warranty of merchantability or fitness for a particular use. The
 * author assumes no responsibility for, and shall not be liable for, any
 * special, indirect, or consequential damages, or any damages whatsoever,
 * arising out of or in connection with the use of this software.
 */

class StringScanner {
    private char[] buf;
    private int idx;
    private int len;
    private String stringDelimiters = "";

    public StringScanner(String s) {
        buf = new char[s.length() + 1];
        s.getChars(0, s.length(), buf, 0);
        len = s.length();
        buf[len] = 0;
        idx = 0;
    }

    public int getIndex() {
        return idx;
    }

    public void setIndex(int i) {
        if (i < 0) {
            idx = 0;
        } else if (i > len) {
            idx = len;
        } else {
            idx = i;
        }
    }

    public void setStringDelimiters(String s) {
        stringDelimiters = s;
    }

    public String getStringDelimiters() {
        return stringDelimiters;
    }

    public char scanChar() throws StringScanException {
        int idxSave = idx;
        skipWhiteSpace();
        try {
            if (buf[idx] == '\'') {
                return scanQuotedChar();
            } else {
                return scanUnquotedChar();
            }
        } catch (StringScanException e) {
            idx = idxSave;
            throw e;
        }
    }

    public char scanQuotedChar() throws StringScanException {
        StringScanException exception = null;
        char retval = 0;
        int idxSave = idx;

        skipWhiteSpace();
        if (idx == len) {
            exception = new StringScanException(idx, "end of input");
        } else if (buf[idx++] == '\'') {
            try {
                retval = scanUnquotedChar();
            } catch (StringScanException e) {
                exception = e;
            }
            if (exception == null) {
                if (idx == len) {
                    exception = new StringScanException(idx, "end of input");
                } else if (buf[idx++] != '\'') {
                    exception = new StringScanException(idx - 1,
                            "unclosed quoted character");
                }
            }
        } else {
            exception = new StringScanException(idx - 1,
                    "uninitialized quoted character");
        }
        if (exception != null) {
            idx = idxSave;
            throw exception;
        }
        return retval;
    }

    public char scanUnquotedChar() throws StringScanException {
        StringScanException exception = null;
        char c, retval = 0;
        int idxSave = idx;

        if (idx == len) {
            exception = new StringScanException(idx, "end of input");
        } else if ((c = buf[idx++]) == '\\') {
            if (idx == len) {
                exception = new StringScanException(idx, "end of input");
            } else {
                c = buf[idx++];
                if (c == '"') {
                    retval = '"';
                } else if (c == '\'') {
                    retval = '\'';
                } else if (c == '\\') {
                    retval = '\\';
                } else if (c == 'n') {
                    retval = '\n';
                } else if (c == 't') {
                    retval = '\t';
                } else if (c == 'b') {
                    retval = '\b';
                } else if (c == 'r') {
                    retval = '\r';
                } else if (c == 'f') {
                    retval = '\f';
                } else if ('0' <= c && c < '8') {
                    int v = c - '0';
                    for (int j = 0; j < 2; j++) {
                        if (idx == len) {
                            break;
                        }
                        c = buf[idx];
                        if ('0' <= c && c < '8' && (v * 8 + (c - '0')) <= 255) {
                            v = v * 8 + (c - '0');
                            idx++;
                        } else {
                            break;
                        }
                    }
                    retval = (char) v;
                } else {
                    exception = new StringScanException(idx - 1,
                            "illegal escape character '" + c + "'");
                }
            }
        } else {
            retval = c;
        }
        if (exception != null) {
            idx = idxSave;
            throw exception;
        }
        return retval;
    }

    public String scanQuotedString() throws StringScanException {
        StringScanException exception = null;
        StringBuffer sbuf = new StringBuffer(len);
        char c;
        int idxSave = idx;

        skipWhiteSpace();
        if (idx == len) {
            exception = new StringScanException(idx, "end of input");
        } else if ((c = buf[idx++]) == '"') {
            while (idx < len && (c = buf[idx]) != '"' && c != '\n') {
                if (c == '\\') {
                    try {
                        c = scanUnquotedChar();
                    } catch (StringScanException e) {
                        exception = e;
                        break;
                    }
                } else {
                    idx++;
                }
                sbuf.append(c);
            }
            if (exception == null && idx >= len) {
                exception = new StringScanException(len, "end of input");
            } else if (exception == null && c == '\n') {
                exception = new StringScanException(idx,
                        "unclosed quoted string");
            } else {
                idx++;
            }
        } else {
            exception = new StringScanException(idx - 1,
                    "quoted string must start with \"");
        }
        if (exception != null) {
            idx = idxSave;
            throw exception;
        }
        return sbuf.toString();
    }

    public String scanNonWhiteSpaceString() throws StringScanException {
        StringBuffer sbuf = new StringBuffer(len);
        int idxSave = idx;
        char c;

        skipWhiteSpace();
        if (idx == len) {
            StringScanException e = new StringScanException(idx, "end of input");
            idx = idxSave;
            throw e;
        } else {
            c = buf[idx++];
            while (idx < len && !Character.isWhitespace(c)
                    && stringDelimiters.indexOf(c) == -1) {
                sbuf.append(c);
                c = buf[idx++];
            }
            if (Character.isWhitespace(c) || stringDelimiters.indexOf(c) != -1) {
                idx--;
            } else {
                sbuf.append(c);
            }
        }
        return sbuf.toString();
    }

    public String scanString() throws StringScanException {
        int idxSave = idx;
        skipWhiteSpace();
        try {
            if (buf[idx] == '"') {
                return scanQuotedString();
            } else {
                return scanNonWhiteSpaceString();
            }
        } catch (StringScanException e) {
            idx = idxSave;
            throw e;
        }
    }

    public String getString() throws StringScanException {
        StringBuffer sbuf = new StringBuffer(len);
        while (idx < len) {
            sbuf.append(buf[idx++]);
        }
        return sbuf.toString();
    }

    public long scanInt() throws StringScanException {
        int idxSave = idx;
        char c;
        int sign = 1;

        skipWhiteSpace();
        if ((c = buf[idx]) == '-' || c == '+') {
            sign = (c == '-' ? -1 : 1);
            idx++;
        }
        try {
            if (idx == len) {
                throw new StringScanException(len, "end of input");
            } else if ((c = buf[idx]) == '0') {
                if ((c = buf[idx + 1]) == 'x' || c == 'X') {
                    idx += 2;
                    return sign * scanInt(16, false);
                } else {
                    return sign * scanInt(8, false);
                }
            } else {
                return sign * scanInt(10, false);
            }
        } catch (StringScanException e) {
            idx = idxSave;
            throw e;
        }
    }

    public long scanInt(int radix) throws StringScanException {
        return scanInt(radix, /* skipWhite= */true);
    }

    private String baseDesc(int radix) {
        switch (radix) {
        case 10: {
            return "decimal";
        }
        case 8: {
            return "octal";
        }
        case 16: {
            return "hex";
        }
        default: {
            return "base " + radix;
        }
        }
    }

    public long scanInt(int radix, boolean skipWhite)
            throws StringScanException {
        StringScanException exception = null;
        int charval, idxSave = idx;
        char c;
        long val = 0;
        boolean negate = false;

        if (skipWhite) {
            skipWhiteSpace();
        }
        if ((c = buf[idx]) == '-' || c == '+') {
            negate = (c == '-');
            idx++;
        }
        if (idx >= len) {
            exception = new StringScanException(len, "end of input");
        } else if ((charval = Character.digit(buf[idx++], radix)) == -1) {
            exception = new StringScanException(idx - 1, "malformed "
                    + baseDesc(radix) + " integer");
        } else {
            val = charval;
            while ((charval = Character.digit(buf[idx], radix)) != -1) {
                val = val * radix + charval;
                idx++;
            }
            if (Character.isLetter(c = buf[idx]) || Character.isDigit(c)
                    || c == '_') {
                exception = new StringScanException(idx, "malformed "
                        + baseDesc(radix) + " integer");
            }
        }
        if (exception != null) {
            idx = idxSave;
            throw exception;
        }
        return negate ? -val : val;
    }

    public double scanDouble() throws StringScanException {
        StringScanException exception = null;
        int idxSave = idx;
        char c;
        // parse [-][0-9]*[.][0-9]*[eE][-][0-9]*
        boolean hasDigits = false;
        boolean signed;
        double value = 0;

        skipWhiteSpace();
        if (idx == len) {
            exception = new StringScanException("end of input");
        } else {
            if ((c = buf[idx]) == '-' || c == '+') {
                signed = true;
                idx++;
            }
            if (matchDigits()) {
                hasDigits = true;
            }
            if (buf[idx] == '.') {
                idx++;
            }
            if (!hasDigits && (buf[idx] < '0' || buf[idx] > '9')) {
                if (idx == len) {
                    exception = new StringScanException(idx, "end of input");
                } else {
                    exception = new StringScanException(idx,
                            "malformed floating number: no digits");
                }
            } else {
                matchDigits();

                if ((c = buf[idx]) == 'e' || c == 'E') {
                    idx++;
                    if ((c = buf[idx]) == '-' || c == '+') {
                        signed = true;
                        idx++;
                    }
                    if (buf[idx] < '0' || buf[idx] > '9') {
                        if (idx == len) {
                            exception = new StringScanException(idx,
                                    "end of input");
                        } else {
                            exception = new StringScanException(idx,
                                    "malformed floating number: no digits in exponent");
                        }
                    } else {
                        matchDigits();
                    }
                }
            }
        }
        if (exception == null) {
            // if (Character.isLetterOrDigit(c=buf[idx]) || c == '_')
            // { exception = new StringScanException (idx,
            // "malformed floating number");
            // }
            // else
            {
                try {
                    value = Double.parseDouble(new String(buf, idxSave, idx
                            - idxSave));
                } catch (NumberFormatException e) {
                    exception = new StringScanException(idx,
                            "malformed floating number");
                }
            }
        }
        if (exception != null) {
            idx = idxSave;
            throw exception;
        }
        return value;
    }

    public boolean scanBoolean() throws StringScanException {
        StringScanException exception = null;
        int idxSave = idx;
        String testStr = "false";
        boolean testval = false;
        char c;

        skipWhiteSpace();
        if (buf[idx] == 't') {
            testStr = "true";
            testval = true;
        } else {
            testval = false;
        }
        int i = 0;
        for (i = 0; i < testStr.length(); i++) {
            if (testStr.charAt(i) != buf[idx]) {
                if (idx == len) {
                    exception = new StringScanException(idx, "end of input");
                }
                break;
            }
            idx++;
        }
        if (exception == null) {
            if (i < testStr.length() || Character.isLetterOrDigit(c = buf[idx])
                    || c == '_') {
                exception = new StringScanException(idx, "illegal boolean");
            }
        }
        if (exception != null) {
            idx = idxSave;
            throw exception;
        }
        return testval;
    }

    public boolean matchString(String s) {
        int k = idx;
        for (int i = 0; i < s.length(); i++) {
            if (k >= len || s.charAt(i) != buf[k++]) {
                return false;
            }
        }
        idx = k;
        return true;
    }

    public boolean matchDigits() {
        int k = idx;
        char c;

        while ((c = buf[k]) >= '0' && c <= '9') {
            k++;
        }
        if (k > idx) {
            idx = k;
            return true;
        } else {
            return false;
        }
    }

    public void skipWhiteSpace() {
        while (Character.isWhitespace(buf[idx])) {
            idx++;
        }
    }

    private int skipWhiteSpace(int k) {
        while (Character.isWhitespace(buf[k])) {
            k++;
        }
        return k;
    }

    public boolean atEnd() {
        return idx == len;
    }

    public boolean atBeginning() {
        return idx == 0;
    }

    public void ungetc() {
        if (idx > 0) {
            idx--;
        }
    }

    public char getc() {
        char c = buf[idx];
        if (idx < len) {
            idx++;
        }
        return c;
    }

    public char peekc() {
        return buf[idx];
    }

    public String substring(int i0, int i1) {
        if (i0 < 0) {
            i0 = 0;
        } else if (i0 >= len) {
            i0 = len - 1;
        }
        if (i1 < 0) {
            i1 = 0;
        } else if (i1 > len) {
            i1 = len;
        }
        if (i1 <= i0) {
            return "";
        }
        return new String(buf, i0, i1 - i0);
    }

    public String substring(int i0) {
        if (i0 < 0) {
            i0 = 0;
        }
        if (i0 >= len) {
            return "";
        } else {
            return new String(buf, i0, len - i0);
        }
    }
}