pystring.java

无线通信的主要编程软件,是无线通信工作人员的必备工具,关天相关教程我会在后续传上.

/// Copyright (c) Corporation for National Research Initiatives
package org.python.core;

import java.io.Serializable;


class StringFuncs extends PyBuiltinFunctionSet
{
    StringFuncs(String name, int index, int argcount) {
        super(name, index, argcount, argcount, true, null);
    }

    StringFuncs(String name, int index, int mincount, int maxcount) {
        super(name, index, mincount, maxcount, true, null);
    }

    private String tostring(PyObject o) {
        if (o == Py.None)
            return null;
        if (o instanceof PyString)
            return ((PyString)o).toString();
        throw Py.TypeError("1st arg can't be coerced to string");
    }

    private String tostring(PyObject o, String which) {
        if (o instanceof PyString)
            return ((PyString)o).toString();
        throw Py.TypeError(which + " arg can't be coerced to string");
    }

    private int toint(PyObject o) {
        if (o instanceof PyInteger)
            return ((PyInteger)o).getValue();
        throw Py.TypeError("2nd arg can't be coerced to int");
    }

    private int toint(PyObject o, String which) {
        if (o instanceof PyInteger)
            return ((PyInteger)o).getValue();
        throw Py.TypeError(which + " arg can't be coerced to int");
    }

    public PyObject __call__() {
        PyString s = (PyString)__self__;
        switch (index) {
        case 1:
            return s.__str__();
        case 2:
            return new PyInteger(s.__len__());
        case 3:
            return s.__repr__();
        case 4:
            return Py.newBoolean(s.islower());
        case 5:
            return Py.newBoolean(s.isalpha());
        case 6:
            return Py.newBoolean(s.isdigit());
        case 7:
            return Py.newBoolean(s.isupper());
        case 8:
            return Py.newBoolean(s.isspace());
        case 9:
            return Py.newBoolean(s.istitle());
        case 10:
            return Py.newBoolean(s.isnumeric());
        case 101:
            return new PyString(s.lower());
        case 102:
            return new PyString(s.upper());
        case 103:
            return new PyString(s.swapcase());
        case 104:
            return new PyString(s.strip());
        case 105:
            return new PyString(s.lstrip());
        case 106:
            return new PyString(s.rstrip());
        case 107:
            return s.split();
        case 113:
            return new PyString(s.capitalize());
        default:
            throw argCountError(0);
        }
    }

    public PyObject __call__(PyObject arg) {
        PyString s = (PyString)__self__;
        switch (index) {
        case 11:
            return new PyInteger(s.__cmp__(arg));
        case 12:
            return s.__add__(arg);
        case 13:
            return s.__mod__(arg);
        case 104:
            return new PyString(s.strip(tostring(arg)));
        case 105:
            return new PyString(s.lstrip(tostring(arg)));
        case 106:
            return new PyString(s.rstrip(tostring(arg)));
        case 107:
            return s.split(tostring(arg));
        case 108:
            return new PyInteger(s.index(tostring(arg)));
        case 109:
            return new PyInteger(s.rindex(tostring(arg)));
        case 110:
            return new PyInteger(s.count(tostring(arg)));
        case 111:
            return new PyInteger(s.find(tostring(arg)));
        case 112:
            return new PyInteger(s.rfind(tostring(arg)));
        case 114:
            return new PyInteger(s.endswith(tostring(arg)) ? 1 : 0);
        case 115:
            return new PyString(s.join(arg));
        case 117:
            return new PyInteger(s.startswith(tostring(arg)) ? 1 : 0);
        case 118:
            if (arg instanceof PyString)
                return new PyString(s.translate(tostring(arg)));
            else
                return new PyString(s.translate(arg));
        default:
            throw argCountError(1);
        }
    }

    public PyObject __call__(PyObject arg1, PyObject arg2) {
        PyString s = (PyString)__self__;
        String args, args1, args2;
        int argi;
        switch (index) {
        case 107:
            args = tostring(arg1);
            argi = toint(arg2);
            return s.split(args, argi);
        case 108:
            args = tostring(arg1);
            argi = toint(arg2);
            return new PyInteger(s.index(args, argi));
        case 109:
            args = tostring(arg1);
            argi = toint(arg2);
            return new PyInteger(s.rindex(args, argi));
        case 110:
            args = tostring(arg1);
            argi = toint(arg2);
            return new PyInteger(s.count(args, argi));
        case 111:
            args = tostring(arg1);
            argi = toint(arg2);
            return new PyInteger(s.find(args, argi));
        case 112:
            args = tostring(arg1);
            argi = toint(arg2);
            return new PyInteger(s.rfind(args, argi));
        case 114:
            args = tostring(arg1);
            argi = toint(arg2);
            return new PyInteger(s.endswith(args, argi) ? 1 : 0);
        case 116:
            args1 = tostring(arg1);
            args2 = tostring(arg2, "2nd");
            return new PyString(s.replace(args1, args2));
        case 117:
            args = tostring(arg1);
            argi = toint(arg2);
            return new PyInteger(s.startswith(args, argi) ? 1 : 0);
        case 118:
            args1 = tostring(arg1);
            args2 = tostring(arg2, "2nd");
            return new PyString(s.translate(args1, args2));
        default:
            throw argCountError(2);
        }
    }

    public PyObject __call__(PyObject arg1, PyObject arg2, PyObject arg3) {
        PyString s = (PyString)__self__;
        String args, args1, args2;
        int argi, argi2, argi3;
        switch (index) {
        case 108:
            args = tostring(arg1);
            argi2 = toint(arg2);
            argi3 = toint(arg3, "3rd");
            return new PyInteger(s.index(args, argi2, argi3));
        case 109:
            args = tostring(arg1);
            argi2 = toint(arg2);
            argi3 = toint(arg3, "3rd");
            return new PyInteger(s.rindex(args, argi2, argi3));
        case 110:
            args = tostring(arg1);
            argi2 = toint(arg2);
            argi3 = toint(arg3, "3rd");
            return new PyInteger(s.count(args, argi2, argi3));
        case 111:
            args = tostring(arg1);
            argi2 = toint(arg2);
            argi3 = toint(arg3, "3rd");
            return new PyInteger(s.find(args, argi2, argi3));
        case 112:
            args = tostring(arg1);
            argi2 = toint(arg2);
            argi3 = toint(arg3, "3rd");
            return new PyInteger(s.rfind(args, argi2, argi3));
        case 114:
            args = tostring(arg1);
            argi2 = toint(arg2);
            argi3 = toint(arg3, "3rd");
            return new PyInteger(s.endswith(args, argi2, argi3) ? 1 : 0);
        case 116:
            args1 = tostring(arg1);
            args2 = tostring(arg2, "2nd");
            argi = toint(arg3, "3rd");
            return new PyString(s.replace(args1, args2, argi));
        case 117:
            args = tostring(arg1);
            argi2 = toint(arg2);
            argi3 = toint(arg3, "3rd");
            return new PyInteger(s.startswith(args, argi2, argi3) ? 1 : 0);
        default:
            throw argCountError(3);
        }
    }
}




/**
 * A builtin python string.
 */
public class PyString extends PySequence implements ClassDictInit
{
    private String string;
    private transient int cached_hashcode=0;
    private transient boolean interned=false;

    // for PyJavaClass.init()
    public PyString() {
        string = "";
    }

    public PyString(String string) {
        if (string == null) {
            throw new IllegalArgumentException(
                            "Cannot create PyString from null!");
        }
        this.string = string;
    }

    public PyString(char c) {
        this(String.valueOf(c));
    }

    /** <i>Internal use only. Do not call this method explicit.</i> */
    public static void classDictInit(PyObject dict) {
        dict.__setitem__("__str__", new StringFuncs("__str__", 1, 0));
        dict.__setitem__("__len__", new StringFuncs("__len__", 2, 0));
        dict.__setitem__("__repr__", new StringFuncs("__repr__", 3, 0));
        dict.__setitem__("islower", new StringFuncs("islower", 4, 0));
        dict.__setitem__("isalpha", new StringFuncs("isalpha", 5, 0));
        dict.__setitem__("isdigit", new StringFuncs("isdigit", 6, 0));
        dict.__setitem__("isupper", new StringFuncs("isupper", 7, 0));
        dict.__setitem__("isspace", new StringFuncs("isspace", 8, 0));
        dict.__setitem__("istitle", new StringFuncs("istitle", 9, 0));
        dict.__setitem__("isnumeric", new StringFuncs("isnumeric", 10, 0));
        dict.__setitem__("__cmp__", new StringFuncs("__cmp__", 11, 1));
        dict.__setitem__("__add__", new StringFuncs("__add__", 12, 1));
        dict.__setitem__("__mod__", new StringFuncs("__mod__", 13, 1));
        // new experimental string methods
        dict.__setitem__("lower", new StringFuncs("lower", 101, 0));
        dict.__setitem__("upper", new StringFuncs("upper", 102, 0));
        dict.__setitem__("swapcase", new StringFuncs("swapcase", 103, 0));
        dict.__setitem__("strip", new StringFuncs("strip", 104, 0, 1));
        dict.__setitem__("lstrip", new StringFuncs("lstrip", 105, 0, 1));
        dict.__setitem__("rstrip", new StringFuncs("rstrip", 106, 0, 1));
        dict.__setitem__("split", new StringFuncs("split", 107, 0, 2));
        dict.__setitem__("index", new StringFuncs("index", 108, 1, 3));
        dict.__setitem__("rindex", new StringFuncs("rindex", 109, 1, 3));
        dict.__setitem__("count", new StringFuncs("count", 110, 1, 3));
        dict.__setitem__("find", new StringFuncs("find", 111, 1, 3));
        dict.__setitem__("rfind", new StringFuncs("rfind", 112, 1, 3));
        dict.__setitem__("capitalize", new StringFuncs("capitalize", 113, 0));
        dict.__setitem__("endswith", new StringFuncs("endswith", 114, 1, 3));
        dict.__setitem__("join", new StringFuncs("join", 115, 1));
        dict.__setitem__("replace", new StringFuncs("replace", 116, 2, 3));
        dict.__setitem__("startswith",
                         new StringFuncs("startswith", 117, 1, 3));
        dict.__setitem__("translate",
                         new StringFuncs("translate", 118, 1, 2));
        // TBD: CPython currently doesn't have these as string methods, but
        // they'd be easy to add for JPython.  For now, compatibility says
        // to access these only through the string module
        //
        // ljust()
        // rjust()
        // center()
        // zfill()
        // expandtabs()
        // capwords()
        //
        // Hide these from Python!
        dict.__setitem__("toString", null);
        dict.__setitem__("internedString", null);
        dict.__setitem__("hashCode", null);
        dict.__setitem__("equals", null);
        dict.__setitem__("__int__", null);
        dict.__setitem__("__long__", null);
        dict.__setitem__("__float__", null);
        dict.__setitem__("__tojava__", null);
        dict.__setitem__("atof", null);
        dict.__setitem__("atoi", null);
        dict.__setitem__("atol", null);
        dict.__setitem__("encode_UnicodeEscape", null);
        dict.__setitem__("decode_UnicodeEscape", null);
    }

    public String safeRepr() throws PyIgnoreMethodTag {
        return "'string' object";
    }

    public PyString __str__() {
        return this;
    }

    public int __len__() {
        return string.length();
    }

    public String toString() {
        return string;
    }

    public String internedString() {
        if (interned)
            return string;
        else {
            string = string.intern();
            interned = true;
            return string;
        }
    }

    public PyString __repr__() {
        return new PyString(encode_UnicodeEscape(string, true));
    }

    private static char[] hexdigit = "0123456789ABCDEF".toCharArray();

    public static String encode_UnicodeEscape(String str,
                                              boolean use_quotes)
    {
        int size = str.length();
        StringBuffer v = new StringBuffer(str.length());

        char quote = 0;
        boolean unicode = false;

        if (use_quotes) {
            quote = str.indexOf('\'') >= 0 &&
                             str.indexOf('"') == -1 ? '"' : '\'';
            v.append(quote);
        }

        for (int i = 0; size-- > 0; ) {
            int ch = str.charAt(i++);
            /* Escape quotes */
            if (use_quotes && (ch == quote || ch == '\\')) {
                v.append('\\');
                v.append((char) ch);
            }
            /* Map 16-bit characters to '\\uxxxx' */
            else if (ch >= 256) {
                if (use_quotes && !unicode) {
                   v.insert(0, 'u');
                   unicode = true;
                }
                v.append('\\');
                v.append('u');
                v.append(hexdigit[(ch >> 12) & 0xf]);
                v.append(hexdigit[(ch >> 8) & 0xf]);
                v.append(hexdigit[(ch >> 4) & 0xf]);
                v.append(hexdigit[ch & 15]);
            }
            /* Map non-printable US ASCII to '\ooo' */
            else if (use_quotes && ch == '\n') v.append("\\n");
            else if (use_quotes && ch == '\t') v.append("\\t");
            else if (use_quotes && ch == '\b') v.append("\\b");
            else if (use_quotes && ch == '\f') v.append("\\f");
            else if (use_quotes && ch == '\r') v.append("\\r");
            else if (ch < ' ' || ch >= 127) {
                v.append("\\x");
                v.append(hexdigit[(ch >> 4) & 0xF]);
                v.append(hexdigit[ch & 0xF]);
            }
            /* Copy everything else as-is */
            else
                v.append((char) ch);
        }
        if (use_quotes)
            v.append(quote);
        return v.toString();
    }

    private static ucnhashAPI pucnHash = null;

    public static String decode_UnicodeEscape(String str, int start, int end,
                                              String errors, boolean unicode)
    {
        StringBuffer v = new StringBuffer(end-start);
        for (int s = start; s < end; ) {
            char ch = str.charAt(s);

            /* Non-escape characters are interpreted as Unicode ordinals */
            if (ch != '\\') {
                v.append(ch);
                s++;
                continue;
            }

            /* \ - Escapes */
            s++;
            ch = str.charAt(s++);
            switch (ch) {

            /* \x escapes */
            case '\n': break;
            case '\\': v.append('\\'); break;