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

public static String encode_UnicodeEscape(String str, boolean use_quotes) {

int size = str.length();

StringBuilder v = new StringBuilder(str.length());

char quote = 0;

if (use_quotes) {

quote = str.indexOf('\'') >= 0 && str.indexOf('"') == -1 ? '"' : '\'';

v.append(quote);

}

for (int i = 0; size-- > 0; ) {

char ch = str.charAt(i++);

/* Escape quotes */

if ((use_quotes && ch == quote) || ch == '\\') {

v.append('\\');

v.append(ch);

continue;

}

/* Map UTF-16 surrogate pairs to Unicode \UXXXXXXXX escapes */

else if (size > 0 && Character.isHighSurrogate(ch)) {

char ch2 = str.charAt(i++);

size--;

if (Character.isLowSurrogate(ch2)) {

int ucs = Character.toCodePoint(ch, ch2);//((ch & 0x03FF) << 10) | (ch2 & 0x03FF)) + 0x00010000;

if (UCharacter.isPrintable(ucs)) {

v.appendCodePoint(ucs);

} else {

v.append('\\');

v.append('U');

v.append(hexdigit[(ucs >> 28) & 0xf]);

v.append(hexdigit[(ucs >> 24) & 0xf]);

v.append(hexdigit[(ucs >> 20) & 0xf]);

v.append(hexdigit[(ucs >> 16) & 0xf]);

v.append(hexdigit[(ucs >> 12) & 0xf]);

v.append(hexdigit[(ucs >> 8) & 0xf]);

v.append(hexdigit[(ucs >> 4) & 0xf]);

v.append(hexdigit[ucs & 0xf]);

}

continue;

}

/* Fall through: isolated surrogates are copied as-is */

i--;

size++;

}

/* Map 16-bit characters to '\\uxxxx' */

if (ch >= 256 && !UCharacter.isPrintable(ch)) {

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 special whitespace to '\t', \n', '\r' */

else if (ch == '\t') {

v.append("\\t");

} else if (ch == '\n') {

v.append("\\n");

} else if (ch == '\r') {

v.append("\\r");

} else if (ch < ' ' || ch == 127) {

/* Map non-printable US ASCII to '\xNN' */

v.append('\\');

v.append('x');

v.append(hexdigit[(ch >> 4) & 0xf]);

v.append(hexdigit[ch & 0xf]);

} else {/* Copy everything else as-is */

v.append(ch);

}

}

if (use_quotes) {

v.append(quote);

}

return v.toString();

}

public static String decode_UnicodeEscape(String str, int start, int end, String errors,

boolean unicode) {

StringBuilder v = new StringBuilder(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;

}

int loopStart = s;

/* \ - Escapes */

s++;

if (s == end) {

s = codecs.insertReplacementAndGetResume(v, errors, "unicodeescape", //

str, loopStart, s + 1, "\\ at end of string");

continue;

}

ch = str.charAt(s++);

switch (ch) {

/* \x escapes */

case '\n':

break;

case '\\':

v.append('\\');

break;

case '\'':

v.append('\'');

break;

case '\"':

v.append('\"');

break;

case 'b':

v.append('\b');

break;

case 'f':

v.append('\014');

break; /* FF */

case 't':

v.append('\t');

break;

case 'n':

v.append('\n');

break;

case 'r':

v.append('\r');

break;

case 'v':

v.append('\013');

break; /* VT */

case 'a':

v.append('\007');

break; /* BEL, not classic C */

/* \OOO (octal) escapes */

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

int x = Character.digit(ch, 8);

for (int j = 0; j < 2 && s < end; j++, s++) {

ch = str.charAt(s);

if (ch < '0' || ch > '7') {

break;

}

x = (x << 3) + Character.digit(ch, 8);

}

v.append((char) x);

break;

case 'x':

s = hexescape(v, errors, 2, s, str, end, "truncated \\xXX");

break;

case 'u':

if (!unicode) {

v.append('\\');

v.append('u');

break;

}

s = hexescape(v, errors, 4, s, str, end, "truncated \\uXXXX");

break;

case 'U':

if (!unicode) {

v.append('\\');

v.append('U');

break;

}

s = hexescape(v, errors, 8, s, str, end, "truncated \\UXXXXXXXX");

break;

case 'N':

if (!unicode) {

v.append('\\');

v.append('N');

break;

}

/*

if (str.charAt(s) == '{') {

int startName = s + 1;

int endBrace = startName;

/*

endBrace = str.indexOf('}', startName);

if (endBrace != -1) {

int value = UCharacter.getCharFromName(str.substring(startName, endBrace));

if (storeUnicodeCharacter(value, v)) {

s = endBrace + 1;

} else {

s = codecs.insertReplacementAndGetResume( //

v, errors, "unicodeescape", //

str, loopStart, endBrace + 1, "illegal Unicode character");

}

} else {

s = codecs.insertReplacementAndGetResume(v, errors, "unicodeescape", //

str, loopStart, endBrace, "malformed \\N character escape");

}

break;

} else {

s = codecs.insertReplacementAndGetResume(v, errors, "unicodeescape", //

str, loopStart, s + 1, "malformed \\N character escape");

}

break;

default:

v.append('\\');

v.append(str.charAt(s - 1));

break;

}

}

return v.toString();

}

private static int hexescape(StringBuilder partialDecode, String errors, int digits,

int hexDigitStart, String str, int size, String errorMessage) {

int i = 0;

int x = 0;

for (; i < digits; ++i) {

int index = hexDigitStart + i;

if (index >= size) {

return codecs.insertReplacementAndGetResume(partialDecode, errors, "unicodeescape",

str, hexDigitStart - 2, size, errorMessage);

}

char c = str.charAt(index);

int d = Character.digit(c, 16);

if (d == -1) {

return codecs.insertReplacementAndGetResume(partialDecode, errors, "unicodeescape",

str, hexDigitStart - 2, index + 1, errorMessage) - 1;

}

x = (x << 4) & ~0xF;

if (c >= '0' && c <= '9') {

x += c - '0';

} else if (c >= 'a' && c <= 'f') {

x += 10 + c - 'a';

} else {

x += 10 + c - 'A';

}

}

if (storeUnicodeCharacter(x, partialDecode)) {

return hexDigitStart + i;

} else {

return codecs.insertReplacementAndGetResume(partialDecode, errors, "unicodeescape",

str, hexDigitStart - 2, hexDigitStart + i + 1, "illegal Unicode character");

}

}

/* pass in an int since this can be a UCS-4 character */

private static boolean storeUnicodeCharacter(int value, StringBuilder partialDecode) {

if (value >= 0 && value <= SysModule.MAXUNICODE) {

partialDecode.appendCodePoint(value);

return true;

}

return false;

}

/**

public static final String _replace(String s, String oldPiece, String newPiece, int count) {

int len = s.length();

int oldLen = oldPiece.length();

int newLen = newPiece.length();

if (len == 0) {

if (count < 0 && oldLen == 0) {

return newPiece;

}

return s;

} else if (oldLen == 0 && newLen != 0 && count != 0) {

/*

int i = 0;

StringBuilder buffer = new StringBuilder(newPiece);

for (; i < len && (count < 0 || i < count - 1); i++) {

buffer.append(s.charAt(i)).append(newPiece);

}

buffer.append(s.substring(i));

return buffer.toString();

} else {

if (count < 0) {

count = (oldLen == 0) ? len + 1 : len;

}

return Joiner.on(newPiece).join(Pattern.compile(oldPiece, Pattern.LITERAL).split(s, count + 1));

}

}

public static final boolean isLowercase(CharSequence s) {

return s.length() != 0 && CharMatcher.JAVA_LOWER_CASE.matchesAllOf(s);

}

public static final boolean isUppercase(CharSequence s) {

return s.length() != 0 && CharMatcher.JAVA_UPPER_CASE.matchesAllOf(s);

}

public static final boolean isAlpha(CharSequence s) {

return s.length() != 0 && CharMatcher.JAVA_LETTER.matchesAllOf(s);

}

public static final boolean isAlnum(CharSequence s) {

return s.length() != 0 && CharMatcher.JAVA_LETTER_OR_DIGIT.matchesAllOf(s);

}

public static final boolean isDecimal(CharSequence s) {

return s.length() != 0 && CharMatcher.forPredicate(new Predicate<Character>() {

@Override

public boolean apply(Character ch) {

return Character.getType(ch) == Character.DECIMAL_DIGIT_NUMBER;

}

}).matchesAllOf(s);

}

public static final boolean isDigit(CharSequence s) {

return s.length() != 0 && CharMatcher.DIGIT.matchesAllOf(s);

}

public static final boolean isNumeric(CharSequence s) {

return s.length() != 0 && CharMatcher.forPredicate(new Predicate<Character>() {

@Override

public boolean apply(Character ch) {

int type = Character.getType(ch);

return type == Character.DECIMAL_DIGIT_NUMBER || type == Character.LETTER_NUMBER

|| type == Character.OTHER_NUMBER;

}

}).matchesAllOf(s);

}

public static final boolean isTitle(CharSequence s) {

int n = s.length();

/* Shortcut for single character strings */

if (n == 1) {

return Character.isTitleCase(s.charAt(0))

|| Character.isUpperCase(s.charAt(0));

}

boolean cased = false;

boolean previous_is_cased = false;

for (int i = 0; i < n; i++) {

char ch = s.charAt(i);

if (Character.isUpperCase(ch) || Character.isTitleCase(ch)) {

if (previous_is_cased) {

return false;

}

previous_is_cased = true;

cased = true;

} else if (Character.isLowerCase(ch)) {

if (!previous_is_cased) {

return false;

}

previous_is_cased = true;

cased = true;

} else {

previous_is_cased = false;

}

}

return cased;

}

public static final boolean isSpace(CharSequence s) {

return s.length() != 0 && CharMatcher.WHITESPACE.matchesAllOf(s);

}

public static PyObject format(CharSequence s, PyObject formatSpec, boolean bytes) {

// Parse the specification

InternalFormat.Spec spec = InternalFormat.fromText(formatSpec, "__format__");

// Get a formatter for the specification

TextFormatter f = prepareFormatter(spec);

if (f == null) {

// The type code was not recognised

throw InternalFormat.Formatter.unknownFormat(spec.type, "string");

}

f.setBytes(bytes);

// Convert as per specification.

f.format(s);

// Return a result that has the same type (str or unicode) as the formatSpec argument.

return f.pad().getPyResult();

}

/**

@SuppressWarnings("fallthrough")

public static final TextFormatter prepareFormatter(InternalFormat.Spec spec) throws PyException {

// Slight differences between format types

switch (spec.type) {

case InternalFormat.Spec.NONE:

case 's':

// Check for disallowed parts of the specification

if (spec.grouping) {

throw InternalFormat.Formatter.notAllowed("Grouping", "string", spec.type);

} else if (InternalFormat.Spec.specified(spec.sign)) {

throw InternalFormat.Formatter.signNotAllowed("string", '\0');

} else if (spec.alternate) {

throw InternalFormat.Formatter.alternateFormNotAllowed("string");

} else if (spec.align == '=') {

throw InternalFormat.Formatter.alignmentNotAllowed('=', "string");

}

// spec may be incomplete. The defaults are those commonly used for string formats.

spec = spec.withDefaults(InternalFormat.Spec.STRING);

// Get a formatter for the specification

return new TextFormatter(spec);

default:

// The type code was not recognised

return null;

}

}

public static final int[] translateIndices(CharSequence s, PyObject startObj, PyObject endObj, int len) {

int start, end;

int n = len;

int[] result = new int[4];

// Decode the start using slice semantics

if (startObj == null || startObj == Py.None) {

start = 0;

// result[2] = 0 already

} else {

// Convert to int but limit to Integer.MIN_VALUE <= start <= Integer.MAX_VALUE

start = startObj.asIndex(null);

if (start < 0) {

// Negative value means "from the end"

start = n + start;

}

result[2] = start;

}

// Decode the end using slice semantics

if (endObj == null || endObj == Py.None) {

result[1] = result[3] = end = n;

} else {

// Convert to int but limit to Integer.MIN_VALUE <= end <= Integer.MAX_VALUE

end = endObj.asIndex(null);

if (end < 0) {

// Negative value means "from the end"

result[3] = end = end + n;

// Ensure end is safe for String.substring(start,end).

if (end < 0) {

end = 0;

// result[1] = 0 already

} else {

result[1] = end;

}

} else {

result[3] = end;

// Ensure end is safe for String.substring(start,end).

if (end > n) {

result[1] = end = n;

} else {

result[1] = end;

}

}

}

// Ensure start is safe for String.substring(start,end).

if (start < 0) {

start = 0;

// result[0] = 0 already

} else if (start > end) {

result[0] = start = end;

} else {

result[0] = start;

}

return result;

}

public static final CharSequence getslice(CharSequence s, int start, int stop, int step, int sliceLength) {

if (step > 0 && stop < start) {

stop = start;

}

if (step == 1) {

return s.subSequence(start, stop);

}

int n = sliceLength;

char new_chars[] = new char[n];

int j = 0;

for (int i = start; j < n; i += step) {

new_chars[j++] = s.charAt(i);

}

return new String(new_chars);

}

/**

public static String asUTF16StringOrError(PyObject obj) {

// PyUnicode accepted here. Care required in the client if obj is not basic plane.

String ret = asUTF16StringOrNull(obj);

if (ret != null) {

return ret;

} else {

throw Py.TypeError(String.format("must be bytes or a tuple of bytes, not '%s'", obj.getType().fastGetName()));

}

}

/**

private static String asUTF16StringOrNull(PyObject obj) {

if (obj instanceof PyUnicode) {

return ((PyUnicode)obj).getString();

} else if (obj instanceof BufferProtocol) {

// Other object with buffer API: briefly access the buffer

try (PyBuffer buf = ((BufferProtocol)obj).getBuffer(PyBUF.FULL_RO)) {

return buf.toString();

}

}

return null;

}

/**

public static String asStringOrNull(PyObject obj) {

return (obj instanceof PyUnicode) ? null : asUTF16StringOrNull(obj);

}

/**

public static String asStringOrError(PyObject obj) throws PyException {

return asStringOrError(obj, true);

}

public static String asStringOrError(PyObject obj, boolean allowInt) throws PyException {

if (allowInt && obj instanceof PyLong) {

int val = ((PyLong) obj).getValue().intValue();

if (val < 0 || val > 255) {

throw Py.ValueError("byte must be in range(0, 256)");

}

return String.valueOf((char) val);

}

String ret = (obj instanceof PyUnicode) ? null : asUTF16StringOrNull(obj);

if (ret != null) {

return ret;

}

throw Py.TypeError("expected str, bytearray or other buffer compatible object");

}

/**

public static String asStringNullOrError(PyObject obj, String name) throws PyException {

if (obj == null || obj == Py.None) {

return null;

}

String ret = (obj instanceof PyUnicode) ? null : asUTF16StringOrNull(obj);

if (ret != null) {

return ret;

}

// A nameless method is the client

throw Py.TypeError(String.format("a bytes-like object is required, not '%s'",

obj.getType().fastGetName()));

}

/**

public static final List<CharSequence> _rsplit(CharSequence s, String sep, int maxsplit) {

if (sep == null) {

// Split on runs of whitespace

return rsplitfields(s, maxsplit);

} else if (sep.length() == 0) {

throw Py.ValueError("empty separator");

} else {

// Split on specified (non-empty) string

return rsplitfields(s, sep, maxsplit);

}

}

/**

public static List<CharSequence> rsplitfields(CharSequence s, int maxsplit) {

/*

List<CharSequence> list = new ArrayList<>();

int length = s.length(), end = length - 1, splits = 0, index;

if (maxsplit < 0) {

// Make all possible splits: there can't be more than:

maxsplit = length;

}

// end is always the rightmost character not consumed into a piece on the list

while (end >= 0) {

// Find the next occurrence of non-whitespace (working leftwards)

while (end >= 0) {

if (!isWhitespace(s.charAt(end))) {

// Break leaving end pointing at non-whitespace

break;

}

--end;

}

if (end < 0) {

// Only found whitespace so there is no next segment

break;

} else if (splits >= maxsplit) {

// The next segment is the last and contains all characters back to the beginning

index = -1;

} else {

// The next segment runs back to the next next whitespace or beginning

for (index = end; index >= 0; --index) {

if (isWhitespace(s.charAt(index))) {

// Break leaving index pointing at whitespace

break;

}

}

}

// Make a piece from index+1 start up to end+1

list.add(s.subSequence(index + 1, end + 1));

splits++;

// Start next segment search at that point

end = index;

}

return Lists.reverse(list);

}

/**

public static final List<CharSequence> rsplitfields(CharSequence s, String sep, int maxsplit) {

/*

List<CharSequence> list = new ArrayList<>();

int length = s.length();

int sepLength = sep.length();

if (maxsplit < 0) {

// Make all possible splits: there can't be more than:

maxsplit = length + 1;

}

if (maxsplit == 0) {

// Degenerate case

list.add(s);

} else if (sepLength == 0) {

// Empty separator is not allowed

throw Py.ValueError("empty separator");

} else {

// Index of first character of the last piece already on the list

int end = length;

// Add at most maxsplit pieces

for (int splits = 0; splits < maxsplit; splits++) {

// Find the next occurrence of sep (working leftwards)

int index = s.toString().lastIndexOf(sep, end - sepLength);

if (index < 0) {

// No more occurrences of sep: we're done

break;

} else {

// Make a piece from where we found sep up to end

list.add(s.subSequence(index + sepLength, end));

// New end (of next piece) is where we found sep

end = index;

}

}

// Last piece is the rest of the string (even if end==0)

list.add(s.subSequence(0, end));

}

return Lists.reverse(list);

}

/**

public static final int _rfind(CharSequence s, String sub, PyObject startObj, PyObject endObj, int len) {

// Interpret the slice indices as concrete values

int[] indices = translateIndices(s, startObj, endObj, len);

int subLen = sub.length();

if (subLen == 0) {

// Special case: an empty string may be found anywhere, ...

int start = indices[2], end = indices[3];

if (end < 0 || end < start || start > len) {

// ... except ln a reverse slice or beyond the end of the string,

return -1;

} else {

// ... and will be reported at the end of the overlap.

return indices[1];

}

} else {

// General case: search for first match then check against slice.

int start = indices[0], end = indices[1];

int found = s.toString().lastIndexOf(sub, end - subLen);

if (found >= start) {

return found;

} else {

return -1;

}

}

}

// only for BMP

public static final String title(CharSequence s) {

char[] chars = new char[s.length()];

int n = chars.length;

boolean previous_is_cased = false;

for (int i = 0; i < n; i++) {

char ch = s.charAt(i);

if (previous_is_cased) {

chars[i] = Character.toLowerCase(ch);

} else {

chars[i] = Character.toTitleCase(ch);

}

if (Character.isLowerCase(ch) || Character.isUpperCase(ch) || Character.isTitleCase(ch)) {

previous_is_cased = true;

} else {

previous_is_cased = false;

}

}

return new String(chars);

}

public static final String swapcase(CharSequence s) {

char[] chars = new char[s.length()];

int n = chars.length;

for (int i = 0; i < n; i++) {

char c = s.charAt(i);

if (Character.isUpperCase(c)) {

chars[i] = Character.toLowerCase(c);

} else if (Character.isLowerCase(c)) {

chars[i] = Character.toUpperCase(c);

}

}

return new String(chars);

}

/**

public static final String _rstrip(CharSequence s) {

// Rightmost non-whitespace

int right = _stripRight(s);

if (right < 0) {

// They're all whitespace

return "";

} else {

// Substring up to and including this rightmost non-whitespace

return s.subSequence(0, right + 1).toString();

}

}

/**

public static final String _rstrip(CharSequence s, String stripChars) {

if (stripChars == null) {

// Divert to the whitespace version

return _rstrip(s);

} else {

// Rightmost non-matching character

int right = _stripRight(s, stripChars);

// Substring up to and including this rightmost non-matching character (or "")

return s.subSequence(0, right + 1).toString();

}

}

/**

private static final int _stripRight(CharSequence s) {

for (int right = s.length(); --right >= 0;) {

if (!isWhitespace(s.charAt(right))) {

return right;

}

}

return -1;

}

/**

private static final int _stripRight(CharSequence s, String stripChars) {

for (int right = s.length(); --right >= 0;) {

if (stripChars.indexOf(s.charAt(right)) < 0) {

return right;

}

}

return -1;

}

/**

public static final CharSequence _strip(CharSequence s) {

// Rightmost non-whitespace

int right = _stripRight(s);

if (right < 0) {

// They're all whitespace

return "";

} else {

// Leftmost non-whitespace character: right known not to be a whitespace

int left = _stripLeft(s, right);

return s.subSequence(left, right + 1);

}

}

/**