private void finishComposition() { int len = buffer.length(); if (len == 6 && format != SPECIAL_ESCAPE) { char codePoint = (char) getCodePoint(buffer, 2, 5); if (Character.isValidCodePoint(codePoint) && codePoint != 0xFFFF) { buffer.setLength(0); buffer.append(codePoint); sendCommittedText(); return; } } else if (len == 8 && format == SPECIAL_ESCAPE) { int codePoint = getCodePoint(buffer, 2, 7); if (Character.isValidCodePoint(codePoint) && codePoint != 0xFFFF) { buffer.setLength(0); buffer.appendCodePoint(codePoint); sendCommittedText(); return; } } else if (len == 12 && format == SURROGATE_PAIR) { char[] codePoint = {(char) getCodePoint(buffer, 2, 5), (char) getCodePoint(buffer, 8, 11)}; if (Character.isHighSurrogate(codePoint[0]) && Character.isLowSurrogate(codePoint[1])) { buffer.setLength(0); buffer.append(codePoint); sendCommittedText(); return; } } beep(); }
public String read() throws IOException { StringBuilder sb = new StringBuilder(); if (offset == bufferSize) { offset = 0; bufferSize = in.read(buffer); } if (bufferSize == -1 || bufferSize == 0) throw new IOException("No new bytes"); for (; buffer[offset] == ' ' || buffer[offset] == '\t' || buffer[offset] == '\n' || buffer[offset] == '\r'; ++offset) { if (offset == bufferSize - 1) { offset = -1; bufferSize = in.read(buffer); } } for (; offset < bufferSize; ++offset) { if (buffer[offset] == ' ' || buffer[offset] == '\t' || buffer[offset] == '\n' || buffer[offset] == '\r') break; if (Character.isValidCodePoint(buffer[offset])) { sb.appendCodePoint(buffer[offset]); } if (offset == bufferSize - 1) { offset = -1; bufferSize = in.read(buffer); } } return sb.toString(); }
/** * Formats all are legal both upper/lower case * * @param input encoded character using percent characters (such as URL encoding) */ @Override public Character decodeCharacter(PushbackString input) { input.mark(); Character first = input.next(); if (first == null) { input.reset(); return null; } // If this is not an encoded character, return null if (first != '%') { input.reset(); return null; } // Search for exactly 2 hex digits following StringBuilder sb = new StringBuilder(); for (int i = 0; i < 2; i++) { Character c = input.nextHex(); if (c != null) sb.append(c); } if (sb.length() == 2) { try { // Parse the hex digit and create a character int i = Integer.parseInt(sb.toString(), 16); if (Character.isValidCodePoint(i)) { return (char) i; } } catch (NumberFormatException ignored) { } } input.reset(); return null; }
/** * Generate a random string containing UTC characters. * * @param size Number of characters in the string. * @return The random string. */ public String nextString(final int size) { char[] out = new char[size]; for (int i = 0; i < size; ++i) { int c = random.nextInt(128); if (c == '\n' || c == '\t' || c == '\f' || c == '\r' || c == '\b' || (c >= 32 && c < 127)) { out[i] = (char) c; } else { c = random.nextInt(2048); if (c >= 160) { out[i] = (char) c; } else { c = random.nextInt(1 << 16); if (c < 32 || (127 <= c && c < 160) || (8192 <= c && c < 8448) || !Character.isValidCodePoint(c)) { out[i] = '?'; } else { out[i] = (char) c; } } } } return String.valueOf(out); }
@Test public void testUTF8() { for (int i = 1; i <= Character.MAX_CODE_POINT; i++) { if (!Character.isValidCodePoint(i)) continue; String orig = new String(Character.toChars(i)); BSONObject a = new BasicBSONObject(orig, orig); BSONObject b = BSON.decode(BSON.encode(a)); assertEquals(a, b); } }
/** * Returns the advance width of the specified character in this <code>Font</code>. The advance is * the distance from the leftmost point to the rightmost point on the character's baseline. Note * that the advance of a <code>String</code> is not necessarily the sum of the advances of its * characters. * * <p>This method doesn't validate the specified character to be a valid Unicode code point. The * caller must validate the character value using {@link java.lang.Character#isValidCodePoint(int) * Character.isValidCodePoint} if necessary. * * @param codePoint the character (Unicode code point) to be measured * @return the advance width of the specified character in the <code>Font</code> described by this * <code>FontMetrics</code> object. * @see #charsWidth(char[], int, int) * @see #stringWidth(String) */ public int charWidth(int codePoint) { if (!Character.isValidCodePoint(codePoint)) { codePoint = 0xffff; // substitute missing glyph width } if (codePoint < 256) { return getWidths()[codePoint]; } else { char[] buffer = new char[2]; int len = Character.toChars(codePoint, buffer, 0); return charsWidth(buffer, 0, len); } }
/** * Reads next line from the input and: * * <ul> * <li>Converts ascii-encoded \\uxxxx chars to normal characters. * <li>Converts \r, \n and \t to CR, line feed and tab. * <li>But! Keeps a backspace in '\ ', '\=', '\:' etc (non-trimmable space or * non-key-value-breaking :-) equals). * <ul> * Change from BufferedReader to LinebreakPreservingReader was part of fix for bug 1462566 */ protected String getNextLine(LinebreakPreservingReader reader) throws IOException, TranslationException { String ascii = reader.readLine(); if (ascii == null) { return null; } StringBuilder result = new StringBuilder(); for (int cp, len = ascii.length(), i = 0; i < len; i += Character.charCount(cp)) { cp = ascii.codePointAt(i); if (cp == '\\' && ascii.codePointCount(i, len) > 1) { i += Character.charCount(cp); cp = ascii.codePointAt(i); if (cp != 'u') { if (cp == 'n') { cp = '\n'; } else if (cp == 'r') { cp = '\r'; } else if (cp == 't') { cp = '\t'; } else { result.append('\\'); } } else if (dontUnescapeULiterals) { // Put back the \ we swallowed result.append('\\'); } else { // checking if the string is long enough if (ascii.codePointCount(i, len) < 1 + 4) { throw new TranslationException(OStrings.getString("RBFH_ERROR_ILLEGAL_U_SEQUENCE")); } int uStart = ascii.offsetByCodePoints(i, 1); int uEnd = ascii.offsetByCodePoints(uStart, 4); String uStr = ascii.substring(uStart, uEnd); try { cp = Integer.parseInt(uStr, 16); if (!Character.isValidCodePoint(cp)) { throw new TranslationException(OStrings.getString("RBFH_ERROR_ILLEGAL_U_SEQUENCE")); } i = uEnd - Character.charCount(cp); } catch (NumberFormatException ex) { throw new TranslationException(OStrings.getString("RBFH_ERROR_ILLEGAL_U_SEQUENCE"), ex); } } } result.appendCodePoint(cp); } return result.toString(); }
/* */ protected CoderResult decodeLoop( ByteBuffer paramByteBuffer, CharBuffer paramCharBuffer) /* */ { /* 65 */ if (paramByteBuffer.remaining() < 4) /* 66 */ return CoderResult.UNDERFLOW; /* 67 */ int i = paramByteBuffer.position(); /* */ try /* */ { /* */ int j; /* 70 */ if (this.currentBO == 0) { /* 71 */ j = (paramByteBuffer.get() & 0xFF) << 24 | (paramByteBuffer.get() & 0xFF) << 16 | (paramByteBuffer.get() & 0xFF) << 8 | paramByteBuffer.get() & 0xFF; /* */ /* 75 */ if ((j == 65279) && (this.expectedBO != 2)) { /* 76 */ this.currentBO = 1; /* 77 */ i += 4; /* 78 */ } else if ((j == -131072) && (this.expectedBO != 1)) { /* 79 */ this.currentBO = 2; /* 80 */ i += 4; /* */ } else { /* 82 */ if (this.expectedBO == 0) /* 83 */ this.currentBO = 1; /* */ else /* 85 */ this.currentBO = this.expectedBO; /* 86 */ paramByteBuffer.position(i); /* */ } /* */ } /* */ CoderResult localCoderResult; /* 89 */ while (paramByteBuffer.remaining() >= 4) { /* 90 */ j = getCP(paramByteBuffer); /* 91 */ if (Character.isBmpCodePoint(j)) { /* 92 */ if (!paramCharBuffer.hasRemaining()) /* 93 */ return CoderResult.OVERFLOW; /* 94 */ i += 4; /* 95 */ paramCharBuffer.put((char) j); /* 96 */ } else if (Character.isValidCodePoint(j)) { /* 97 */ if (paramCharBuffer.remaining() < 2) /* 98 */ return CoderResult.OVERFLOW; /* 99 */ i += 4; /* 100 */ paramCharBuffer.put(Character.highSurrogate(j)); /* 101 */ paramCharBuffer.put(Character.lowSurrogate(j)); /* */ } else { /* 103 */ return CoderResult.malformedForLength(4); /* */ } /* */ } /* 106 */ return CoderResult.UNDERFLOW; /* */ } finally { /* 108 */ paramByteBuffer.position(i); /* */ } /* */ }
private static boolean containsUEscapeAt(String text, int offset) { if (text.codePointCount(offset, text.length()) < 1 + 1 + 4) { return false; } if (text.codePointAt(text.offsetByCodePoints(offset, 1)) != 'u') { return false; } int uStart = text.offsetByCodePoints(offset, 2); int uEnd = text.offsetByCodePoints(uStart, 4); String uStr = text.substring(uStart, uEnd); try { int uChr = Integer.parseInt(uStr, 16); return Character.isValidCodePoint(uChr); } catch (NumberFormatException ex) { return false; } }
protected CoderResult decodeLoop(ByteBuffer src, CharBuffer dst) { if (src.remaining() < 4) return CoderResult.UNDERFLOW; int mark = src.position(); int cp; try { if (currentBO == NONE) { cp = ((src.get() & 0xff) << 24) | ((src.get() & 0xff) << 16) | ((src.get() & 0xff) << 8) | (src.get() & 0xff); if (cp == BOM_BIG && expectedBO != LITTLE) { currentBO = BIG; mark += 4; } else if (cp == BOM_LITTLE && expectedBO != BIG) { currentBO = LITTLE; mark += 4; } else { if (expectedBO == NONE) currentBO = BIG; else currentBO = expectedBO; src.position(mark); } } while (src.remaining() >= 4) { cp = getCP(src); if (Character.isBmpCodePoint(cp)) { if (!dst.hasRemaining()) return CoderResult.OVERFLOW; mark += 4; dst.put((char) cp); } else if (Character.isValidCodePoint(cp)) { if (dst.remaining() < 2) return CoderResult.OVERFLOW; mark += 4; dst.put(Character.highSurrogate(cp)); dst.put(Character.lowSurrogate(cp)); } else { return CoderResult.malformedForLength(4); } } return CoderResult.UNDERFLOW; } finally { src.position(mark); } }
private static boolean isMonospaced(FontMetrics fontMetrics) { boolean isMonospaced = true; int charWidth = -1; for (int codePoint = 0; codePoint < 128; codePoint++) { if (Character.isValidCodePoint(codePoint)) { char character = (char) codePoint; if (isWordCharacter(character)) { int w = fontMetrics.charWidth(character); if (charWidth != -1) { if (w != charWidth) { isMonospaced = false; break; } } else { charWidth = w; } } } } return isMonospaced; }
/** * Escape control characters in a string and append them to the string buffer * * @param string String to be written * @param sb String builder * @throws CharConversionException Invalid Unicode character */ private static void escapeString(String string, StringBuilder sb) throws CharConversionException { if (string.length() == 0) { return; } // // Find the next special character in the string // int start = 0; Matcher matcher = pattern.matcher(string); while (matcher.find(start)) { int pos = matcher.start(); if (pos > start) { sb.append(string.substring(start, pos)); } start = pos + 1; // // Check for a valid Unicode codepoint // int ch = string.codePointAt(pos); if (!Character.isValidCodePoint(ch)) { throw new CharConversionException("Invalid Unicode character in JSON string value"); } // // Process a supplementary codepoint // if (Character.isSupplementaryCodePoint(ch)) { sb.appendCodePoint(ch); start++; continue; } // // Escape control characters // char c = string.charAt(pos); switch (c) { case '"': sb.append("\\\""); break; case '\\': sb.append("\\\\"); break; case '\b': sb.append("\\b"); break; case '\f': sb.append("\\f"); break; case '\n': sb.append("\\n"); break; case '\r': sb.append("\\r"); break; case '\t': sb.append("\\t"); break; case '/': sb.append("\\/"); break; default: if ((c >= '\u0000' && c <= '\u001F') || (c >= '\u007F' && c <= '\u009F') || (c >= '\u2000' && c <= '\u20FF')) { sb.append("\\u").append(String.format("%04X", (int) c)); } else { sb.append(c); } } } // // Append the remainder of the string // if (start == 0) { sb.append(string); } else if (start < string.length()) { sb.append(string.substring(start)); } }