org.jruby.util

Class StringSupport

java.lang.Object

org.jruby.util.StringSupport

public final class StringSupport
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	StringSupport.NeighborChar
static class	StringSupport.TR rb_str_tr / rb_str_tr_bang
static class	StringSupport.TrTables tr_setup_table

Field Summary

Fields

Modifier and Type	Field and Description
static int	CR_7BIT
static int	CR_BROKEN
static int	CR_MASK
static int	CR_UNKNOWN
static int	CR_VALID
static String[]	EMPTY_STRING_ARRAY
static int	TRANS_SIZE
static Object	UNSAFE

Constructor Summary

Constructors

Constructor and Description
StringSupport()

Method Summary

Methods

Modifier and Type	Method and Description
static org.jruby.util.ByteList	addByteLists(org.jruby.util.ByteList value1, org.jruby.util.ByteList value2)
static boolean	areComparable(CodeRangeable string, CodeRangeable other)
static boolean	areComparableViaCodeRange(CodeRangeable string, CodeRangeable other)
static org.jcodings.Encoding	areCompatible(CodeRangeable string, CodeRangeable other) rb_enc_compatible
static void	associateEncoding(CodeRangeable string, org.jcodings.Encoding enc)
static int	bytesToFixBrokenTrailingCharacter(byte[] bytes, int begin, int byteSize, org.jcodings.Encoding encoding, int usingLength)
static int	bytesToFixBrokenTrailingCharacter(org.jruby.util.ByteList val, int usingLength)
static int	caseCmp(byte[] bytes1, int p1, byte[] bytes2, int p2, int len)
static RubyString	checkEmbeddedNulls(Ruby runtime, IRubyObject ptr)
static void	checkStringSafety(Ruby runtime, IRubyObject value) Check whether input object's string value contains a null byte, and if so throw SecurityError.
static int	choppedLength19(CodeRangeable str, Ruby runtime) MRI: chopped_length
static int	codeLength(org.jcodings.Encoding enc, int c)
static int	codePoint(org.jcodings.Encoding enc, byte[] bytes, int p, int end)
static int	codePoint(Ruby runtime, org.jcodings.Encoding enc, byte[] bytes, int p, int end)
static String	codeRangeAsString(int codeRange)
static int	codeRangeScan(org.jcodings.Encoding enc, byte[] bytes, int p, int len)
static int	codeRangeScan(org.jcodings.Encoding enc, org.jruby.util.ByteList bytes)
static long	codeRangeScanRestartable(org.jcodings.Encoding enc, byte[] bytes, int s, int end, int cr)
static int	CONSTRUCT_MBCLEN_CHARFOUND(int n)
static int	countCommon19(org.jruby.util.ByteList value, Ruby runtime, boolean[] table, StringSupport.TrTables tables, org.jcodings.Encoding enc) rb_str_count
static CodeRangeable	delete_bangCommon19(CodeRangeable rubyString, Ruby runtime, boolean[] squeeze, StringSupport.TrTables tables, org.jcodings.Encoding enc) rb_str_delete_bang
static org.jruby.util.ByteList	dumpCommon(Ruby runtime, org.jruby.util.ByteList byteList) rb_str_dump
static int	encFastMBCLen(byte[] bytes, int p, int e, org.jcodings.Encoding enc)
static String	escapedCharFormat(int c, boolean isUnicode)
static long	getAscii(org.jcodings.Encoding enc, byte[] bytes, int p, int end)
static long	getAscii(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int len)
static int	hexLength(byte[] bytes, int p, int len)
static int	hexLength(byte[] bytes, int p, int len, org.jcodings.Encoding enc)
static int	index(CodeRangeable sourceString, CodeRangeable otherString, int offset, org.jcodings.Encoding enc)
static boolean	isAsciiOnly(CodeRangeable string)
static boolean	isEVStr(byte[] bytes, int p, int end)
static boolean	isEVStr(int c)
static boolean	isIncompleteChar(int b)
static boolean	isSingleByteOptimizable(CodeRangeable string, org.jcodings.Encoding encoding)
static boolean	isUnicode(org.jcodings.Encoding enc)
static int	length(org.jcodings.Encoding enc, byte[] bytes, int p, int end)
static int	MBCLEN_CHARFOUND_LEN(int r)
static boolean	MBCLEN_CHARFOUND_P(int r)
static boolean	MBCLEN_INVALID_P(int r)
static boolean	MBCLEN_NEEDMORE_P(int r)
static int	MBCLEN_NEEDMORE(int n)
static int	memchr(byte[] ptr, int start, int find, int len)
static int	memmem(byte[] aBytes, int aStart, int aLen, byte[] p, int pStart, int pLen)
static int	memsearch(byte[] xBytes, int x0, int m, byte[] yBytes, int y0, int n, org.jcodings.Encoding enc)
static int	multiByteCasecmp(org.jcodings.Encoding enc, org.jruby.util.ByteList value, org.jruby.util.ByteList otherValue)
static boolean	multiByteDowncase(org.jcodings.Encoding enc, byte[] bytes, int s, int end)
static boolean	multiByteSqueeze(Ruby runtime, org.jruby.util.ByteList value, boolean[] squeeze, StringSupport.TrTables tables, org.jcodings.Encoding enc, boolean isArg)
static boolean	multiByteSwapcase(Ruby runtime, org.jcodings.Encoding enc, byte[] bytes, int s, int end)
static boolean	multiByteUpcase(org.jcodings.Encoding enc, byte[] bytes, int s, int end)
static int	nth(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int n)
static int	nth(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int n, boolean singlebyte) Get the position of the nth character in the given byte array, using the given encoding and range.
static int	octLength(byte[] bytes, int p, int len)
static int	octLength(byte[] bytes, int p, int len, org.jcodings.Encoding enc)
static int	offset(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int n)
static int	offset(org.jcodings.Encoding enc, byte[] bytes, int p, int end, int n, boolean singlebyte)
static int	offset(RubyString str, int pos)
static int	positionEndForScan(org.jruby.util.ByteList value, org.joni.Matcher matcher, org.jcodings.Encoding enc, int begin, int range) rb_str_scan
static int	preciseCodePoint(org.jcodings.Encoding enc, byte[] bytes, int p, int end)
static int	preciseLength(org.jcodings.Encoding enc, byte[] bytes, int p, int end)
static IRubyObject	rbStrEnumerateLines(RubyString str, ThreadContext context, String name, IRubyObject arg, Block block, boolean wantarray)
static org.jruby.util.ByteList	replaceInternal(int beg, int len, ByteListHolder source, CodeRangeable repl)
static void	replaceInternal19(int beg, int len, CodeRangeable source, CodeRangeable repl)
static void	replaceInternal19(Ruby runtime, int beg, int len, RubyString source, RubyString repl)
static int	rindex(org.jruby.util.ByteList source, int sourceChars, int subChars, int pos, CodeRangeable subStringCodeRangeable, org.jcodings.Encoding enc)
static int	scanHex(byte[] bytes, int p, int len)
static int	scanHex(byte[] bytes, int p, int len, org.jcodings.Encoding enc)
static int	scanOct(byte[] bytes, int p, int len)
static int	scanOct(byte[] bytes, int p, int len, org.jcodings.Encoding enc)
static int	searchNonAscii(byte[] bytes, int p, int end)
static int	searchNonAscii(org.jruby.util.ByteList bytes)
static boolean	singleByteDowncase(byte[] bytes, int s, int end)
static boolean	singleByteSqueeze(org.jruby.util.ByteList value, boolean[] squeeze)
static boolean	singleByteSwapcase(byte[] bytes, int s, int end) rb_str_swapcase / rb_str_swapcase_bang
static boolean	singleByteUpcase(byte[] bytes, int s, int end)
static RubyString	strFillTerm(RubyString str, byte[] sBytes, int s, int len, int oldtermlen, int termlen)
static int	strLength(org.jruby.util.ByteList bytes)
static int	strLength(org.jcodings.Encoding enc, byte[] bytes, int p, int end)
static int	strLength(org.jcodings.Encoding enc, byte[] bytes, int p, int e, int cr)
static int	strLengthFromRubyString(CodeRangeable string)
static int	strLengthFromRubyString(CodeRangeable string, org.jcodings.Encoding enc)
static long	strLengthWithCodeRange(org.jruby.util.ByteList bytes)
static long	strLengthWithCodeRange(org.jruby.util.ByteList bytes, org.jcodings.Encoding enc)
static long	strLengthWithCodeRange(org.jcodings.Encoding enc, byte[] bytes, int p, int end)
static int	strNullChar(byte[] sBytes, int s, int len, int minlen, org.jcodings.Encoding enc)
static StringSupport.NeighborChar	succChar(Ruby runtime, org.jcodings.Encoding enc, byte[] bytes, int p, int len)
static org.jruby.util.ByteList	succCommon(Ruby runtime, org.jruby.util.ByteList original)
static void	TERM_FILL(byte[] ptrBytes, int ptr, int termlen)
static int	toLower(org.jcodings.Encoding enc, int c)
static int	toUpper(org.jcodings.Encoding enc, int c)
static boolean	trFind(int c, boolean[] table, StringSupport.TrTables tables)
static int	trNext(StringSupport.TR t, Ruby runtime, org.jcodings.Encoding enc)
static StringSupport.TrTables	trSetupTable(org.jruby.util.ByteList str, Ruby runtime, boolean[] stable, StringSupport.TrTables tables, boolean first, org.jcodings.Encoding enc)
static CodeRangeable	trTransHelper(Ruby runtime, CodeRangeable self, CodeRangeable srcStr, CodeRangeable replStr, boolean sflag) rb_str_tr / rb_str_tr_bang
static int	unpackArg(long cr)
static int	unpackResult(long len)
static int	utf8Length(byte[] bytes, int p, int end)
static int	utf8Length(org.jruby.util.ByteList bytes)
static int	utf8Nth(byte[] bytes, int p, int e, int nth)
static int	utf8Offset(byte[] bytes, int p, int end, int n)
static boolean	zeroFilled(byte[] sBytes, int s, int n)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

CR_MASK

public static final int CR_MASK

See Also:

Constant Field Values

CR_UNKNOWN

public static final int CR_UNKNOWN

See Also:

Constant Field Values

CR_7BIT

public static final int CR_7BIT

See Also:

Constant Field Values

CR_VALID

public static final int CR_VALID

See Also:

Constant Field Values

CR_BROKEN

public static final int CR_BROKEN

See Also:

Constant Field Values

UNSAFE

public static final Object UNSAFE

TRANS_SIZE

public static final int TRANS_SIZE

See Also:

Constant Field Values

EMPTY_STRING_ARRAY

public static final String[] EMPTY_STRING_ARRAY

Constructor Detail

StringSupport

public StringSupport()

Method Detail

codeRangeAsString

public static String codeRangeAsString(int codeRange)

encFastMBCLen

public static int encFastMBCLen(byte[] bytes,
                int p,
                int e,
                org.jcodings.Encoding enc)

length

public static int length(org.jcodings.Encoding enc,
         byte[] bytes,
         int p,
         int end)

preciseLength

public static int preciseLength(org.jcodings.Encoding enc,
                byte[] bytes,
                int p,
                int end)

MBCLEN_NEEDMORE_P

public static boolean MBCLEN_NEEDMORE_P(int r)

MBCLEN_NEEDMORE

public static int MBCLEN_NEEDMORE(int n)

MBCLEN_INVALID_P

public static boolean MBCLEN_INVALID_P(int r)

MBCLEN_CHARFOUND_LEN

public static int MBCLEN_CHARFOUND_LEN(int r)

MBCLEN_CHARFOUND_P

public static boolean MBCLEN_CHARFOUND_P(int r)

CONSTRUCT_MBCLEN_CHARFOUND

public static int CONSTRUCT_MBCLEN_CHARFOUND(int n)

searchNonAscii

public static int searchNonAscii(byte[] bytes,
                 int p,
                 int end)

searchNonAscii

public static int searchNonAscii(org.jruby.util.ByteList bytes)

codeRangeScan

public static int codeRangeScan(org.jcodings.Encoding enc,
                byte[] bytes,
                int p,
                int len)

codeRangeScan

public static int codeRangeScan(org.jcodings.Encoding enc,
                org.jruby.util.ByteList bytes)

codeRangeScanRestartable

public static long codeRangeScanRestartable(org.jcodings.Encoding enc,
                            byte[] bytes,
                            int s,
                            int end,
                            int cr)

utf8Length

public static int utf8Length(byte[] bytes,
             int p,
             int end)

utf8Length

public static int utf8Length(org.jruby.util.ByteList bytes)

strLength

public static int strLength(org.jcodings.Encoding enc,
            byte[] bytes,
            int p,
            int end)

strLength

public static int strLength(org.jcodings.Encoding enc,
            byte[] bytes,
            int p,
            int e,
            int cr)

strLength

public static int strLength(org.jruby.util.ByteList bytes)

strLengthWithCodeRange

public static long strLengthWithCodeRange(org.jcodings.Encoding enc,
                          byte[] bytes,
                          int p,
                          int end)

strLengthWithCodeRange

public static long strLengthWithCodeRange(org.jruby.util.ByteList bytes)

strLengthWithCodeRange

public static long strLengthWithCodeRange(org.jruby.util.ByteList bytes,
                          org.jcodings.Encoding enc)

unpackResult

public static int unpackResult(long len)

unpackArg

public static int unpackArg(long cr)

codePoint

public static int codePoint(Ruby runtime,
            org.jcodings.Encoding enc,
            byte[] bytes,
            int p,
            int end)

codePoint

public static int codePoint(org.jcodings.Encoding enc,
            byte[] bytes,
            int p,
            int end)

codeLength

public static int codeLength(org.jcodings.Encoding enc,
             int c)

getAscii

public static long getAscii(org.jcodings.Encoding enc,
            byte[] bytes,
            int p,
            int end)

getAscii

public static long getAscii(org.jcodings.Encoding enc,
            byte[] bytes,
            int p,
            int end,
            int len)

preciseCodePoint

public static int preciseCodePoint(org.jcodings.Encoding enc,
                   byte[] bytes,
                   int p,
                   int end)

utf8Nth

public static int utf8Nth(byte[] bytes,
          int p,
          int e,
          int nth)

nth

public static int nth(org.jcodings.Encoding enc,
      byte[] bytes,
      int p,
      int end,
      int n)

nth

public static int nth(org.jcodings.Encoding enc,
      byte[] bytes,
      int p,
      int end,
      int n,
      boolean singlebyte)

Get the position of the nth character in the given byte array, using the given encoding and range.

Parameters:

enc - encoding to use

bytes - bytes to scan

p - starting byte offset

end - ending byte offset

n - index of character for which to find byte offset

singlebyte - whether the byte contents are in a single byte encoding

Returns:

the offset of the nth character in the string, or -1 if nth is out of the string

utf8Offset

public static int utf8Offset(byte[] bytes,
             int p,
             int end,
             int n)

offset

public static int offset(org.jcodings.Encoding enc,
         byte[] bytes,
         int p,
         int end,
         int n)

offset

public static int offset(org.jcodings.Encoding enc,
         byte[] bytes,
         int p,
         int end,
         int n,
         boolean singlebyte)

offset

public static int offset(RubyString str,
         int pos)

toLower

public static int toLower(org.jcodings.Encoding enc,
          int c)

toUpper

public static int toUpper(org.jcodings.Encoding enc,
          int c)

caseCmp

public static int caseCmp(byte[] bytes1,
          int p1,
          byte[] bytes2,
          int p2,
          int len)

scanHex

public static int scanHex(byte[] bytes,
          int p,
          int len)

scanHex

public static int scanHex(byte[] bytes,
          int p,
          int len,
          org.jcodings.Encoding enc)

hexLength

public static int hexLength(byte[] bytes,
            int p,
            int len)

hexLength

public static int hexLength(byte[] bytes,
            int p,
            int len,
            org.jcodings.Encoding enc)

scanOct

public static int scanOct(byte[] bytes,
          int p,
          int len)

scanOct

public static int scanOct(byte[] bytes,
          int p,
          int len,
          org.jcodings.Encoding enc)

octLength

public static int octLength(byte[] bytes,
            int p,
            int len)

octLength

public static int octLength(byte[] bytes,
            int p,
            int len,
            org.jcodings.Encoding enc)

checkStringSafety

public static final void checkStringSafety(Ruby runtime,
                     IRubyObject value)

Check whether input object's string value contains a null byte, and if so throw SecurityError.

Parameters:

runtime -

value -

isUnicode

public static boolean isUnicode(org.jcodings.Encoding enc)

escapedCharFormat

public static String escapedCharFormat(int c,
                       boolean isUnicode)

isIncompleteChar

public static boolean isIncompleteChar(int b)

bytesToFixBrokenTrailingCharacter

public static int bytesToFixBrokenTrailingCharacter(org.jruby.util.ByteList val,
                                    int usingLength)

bytesToFixBrokenTrailingCharacter

public static int bytesToFixBrokenTrailingCharacter(byte[] bytes,
                                    int begin,
                                    int byteSize,
                                    org.jcodings.Encoding encoding,
                                    int usingLength)

memchr

public static int memchr(byte[] ptr,
         int start,
         int find,
         int len)

checkEmbeddedNulls

public static RubyString checkEmbeddedNulls(Ruby runtime,
                            IRubyObject ptr)

strNullChar

public static int strNullChar(byte[] sBytes,
              int s,
              int len,
              int minlen,
              org.jcodings.Encoding enc)

zeroFilled

public static boolean zeroFilled(byte[] sBytes,
                 int s,
                 int n)

strFillTerm

public static RubyString strFillTerm(RubyString str,
                     byte[] sBytes,
                     int s,
                     int len,
                     int oldtermlen,
                     int termlen)

TERM_FILL

public static void TERM_FILL(byte[] ptrBytes,
             int ptr,
             int termlen)

positionEndForScan

public static int positionEndForScan(org.jruby.util.ByteList value,
                     org.joni.Matcher matcher,
                     org.jcodings.Encoding enc,
                     int begin,
                     int range)

rb_str_scan

dumpCommon

public static org.jruby.util.ByteList dumpCommon(Ruby runtime,
                                 org.jruby.util.ByteList byteList)

rb_str_dump

isEVStr

public static boolean isEVStr(byte[] bytes,
              int p,
              int end)

isEVStr

public static boolean isEVStr(int c)

countCommon19

public static int countCommon19(org.jruby.util.ByteList value,
                Ruby runtime,
                boolean[] table,
                StringSupport.TrTables tables,
                org.jcodings.Encoding enc)

rb_str_count

rindex

public static int rindex(org.jruby.util.ByteList source,
         int sourceChars,
         int subChars,
         int pos,
         CodeRangeable subStringCodeRangeable,
         org.jcodings.Encoding enc)

strLengthFromRubyString

public static int strLengthFromRubyString(CodeRangeable string,
                          org.jcodings.Encoding enc)

strLengthFromRubyString

public static int strLengthFromRubyString(CodeRangeable string)

trSetupTable

public static StringSupport.TrTables trSetupTable(org.jruby.util.ByteList str,
                                  Ruby runtime,
                                  boolean[] stable,
                                  StringSupport.TrTables tables,
                                  boolean first,
                                  org.jcodings.Encoding enc)

trFind

public static boolean trFind(int c,
             boolean[] table,
             StringSupport.TrTables tables)

trNext

public static int trNext(StringSupport.TR t,
         Ruby runtime,
         org.jcodings.Encoding enc)

succCommon

public static org.jruby.util.ByteList succCommon(Ruby runtime,
                                 org.jruby.util.ByteList original)

succChar

public static StringSupport.NeighborChar succChar(Ruby runtime,
                                  org.jcodings.Encoding enc,
                                  byte[] bytes,
                                  int p,
                                  int len)

isSingleByteOptimizable

public static boolean isSingleByteOptimizable(CodeRangeable string,
                              org.jcodings.Encoding encoding)

index

public static int index(CodeRangeable sourceString,
        CodeRangeable otherString,
        int offset,
        org.jcodings.Encoding enc)

associateEncoding

public static void associateEncoding(CodeRangeable string,
                     org.jcodings.Encoding enc)

replaceInternal

public static org.jruby.util.ByteList replaceInternal(int beg,
                                      int len,
                                      ByteListHolder source,
                                      CodeRangeable repl)

replaceInternal19

public static void replaceInternal19(int beg,
                     int len,
                     CodeRangeable source,
                     CodeRangeable repl)

replaceInternal19

public static void replaceInternal19(Ruby runtime,
                     int beg,
                     int len,
                     RubyString source,
                     RubyString repl)

isAsciiOnly

public static boolean isAsciiOnly(CodeRangeable string)

delete_bangCommon19

public static CodeRangeable delete_bangCommon19(CodeRangeable rubyString,
                                Ruby runtime,
                                boolean[] squeeze,
                                StringSupport.TrTables tables,
                                org.jcodings.Encoding enc)

rb_str_delete_bang

choppedLength19

public static int choppedLength19(CodeRangeable str,
                  Ruby runtime)

MRI: chopped_length

areCompatible

public static org.jcodings.Encoding areCompatible(CodeRangeable string,
                                  CodeRangeable other)

rb_enc_compatible

addByteLists

public static org.jruby.util.ByteList addByteLists(org.jruby.util.ByteList value1,
                                   org.jruby.util.ByteList value2)

areComparable

public static boolean areComparable(CodeRangeable string,
                    CodeRangeable other)

areComparableViaCodeRange

public static boolean areComparableViaCodeRange(CodeRangeable string,
                                CodeRangeable other)

rbStrEnumerateLines

public static IRubyObject rbStrEnumerateLines(RubyString str,
                              ThreadContext context,
                              String name,
                              IRubyObject arg,
                              Block block,
                              boolean wantarray)

memsearch

public static int memsearch(byte[] xBytes,
            int x0,
            int m,
            byte[] yBytes,
            int y0,
            int n,
            org.jcodings.Encoding enc)

trTransHelper

public static CodeRangeable trTransHelper(Ruby runtime,
                          CodeRangeable self,
                          CodeRangeable srcStr,
                          CodeRangeable replStr,
                          boolean sflag)

rb_str_tr / rb_str_tr_bang

multiByteCasecmp

public static int multiByteCasecmp(org.jcodings.Encoding enc,
                   org.jruby.util.ByteList value,
                   org.jruby.util.ByteList otherValue)

singleByteSqueeze

public static boolean singleByteSqueeze(org.jruby.util.ByteList value,
                        boolean[] squeeze)

multiByteSqueeze

public static boolean multiByteSqueeze(Ruby runtime,
                       org.jruby.util.ByteList value,
                       boolean[] squeeze,
                       StringSupport.TrTables tables,
                       org.jcodings.Encoding enc,
                       boolean isArg)

singleByteSwapcase

public static boolean singleByteSwapcase(byte[] bytes,
                         int s,
                         int end)

rb_str_swapcase / rb_str_swapcase_bang

multiByteSwapcase

public static boolean multiByteSwapcase(Ruby runtime,
                        org.jcodings.Encoding enc,
                        byte[] bytes,
                        int s,
                        int end)

memmem

public static int memmem(byte[] aBytes,
         int aStart,
         int aLen,
         byte[] p,
         int pStart,
         int pLen)

singleByteDowncase

public static boolean singleByteDowncase(byte[] bytes,
                         int s,
                         int end)

multiByteDowncase

public static boolean multiByteDowncase(org.jcodings.Encoding enc,
                        byte[] bytes,
                        int s,
                        int end)

singleByteUpcase

public static boolean singleByteUpcase(byte[] bytes,
                       int s,
                       int end)

multiByteUpcase

public static boolean multiByteUpcase(org.jcodings.Encoding enc,
                      byte[] bytes,
                      int s,
                      int end)