v8::internal::URIUnescape Class Reference

Inheritance diagram for v8::internal::URIUnescape:

Collaboration diagram for v8::internal::URIUnescape:

Public Member Functions
template<typename Char >
MaybeHandle< String >	Unescape (Isolate *isolate, Handle< String > source)
template<typename Char >
MaybeHandle< String >	UnescapeSlow (Isolate *isolate, Handle< String > string, int start_index)

Static Public Member Functions
template<typename Char >
static MUST_USE_RESULT MaybeHandle< String >	Unescape (Isolate *isolate, Handle< String > source)

Static Private Member Functions
template<typename Char >
static MUST_USE_RESULT MaybeHandle< String >	UnescapeSlow (Isolate *isolate, Handle< String > string, int start_index)
static	INLINE (int TwoDigitHex(uint16_t character1, uint16_t character2))
template<typename Char >
static	INLINE (int UnescapeChar(Vector< const Char > vector, int i, int length, int *step))

Static Private Attributes
static const signed char	kHexValue ['g']

Detailed Description

Definition at line 38 of file runtime-uri.cc.

Member Function Documentation

INLINE() [1/2]

static v8::internal::URIUnescape::INLINE ( int   TwoDigitHexuint16_t character1, uint16_t character2 )

staticprivate

INLINE() [2/2]

template<typename Char >

static v8::internal::URIUnescape::INLINE ( int   UnescapeCharVector< const Char > vector, int i, int length, int *step )

staticprivate

Unescape() [1/2]

template<typename Char >

static MUST_USE_RESULT MaybeHandle<String> v8::internal::URIUnescape::Unescape ( Isolate *  isolate, Handle< String >  source  )

static

Unescape() [2/2]

template<typename Char >

MaybeHandle<String> v8::internal::URIUnescape::Unescape	(	Isolate *	isolate,
		Handle< String >	source
	)

Definition at line 70 of file runtime-uri.cc.

                                                                 {
  int index;
  {
    DisallowHeapAllocation no_allocation;
    StringSearch<uint8_t, Char> search(isolate, STATIC_CHAR_VECTOR("%"));
    index = search.Search(GetCharVector<Char>(source), 0);
    if (index < 0) return source;
  }
  return UnescapeSlow<Char>(isolate, source, index);
}

References v8::internal::StringSearch< PatternChar, SubjectChar >::Search(), and STATIC_CHAR_VECTOR.

Here is the call graph for this function:

UnescapeSlow() [1/2]

template<typename Char >

static MUST_USE_RESULT MaybeHandle<String> v8::internal::URIUnescape::UnescapeSlow ( Isolate *  isolate, Handle< String >  string, int  start_index  )

staticprivate

UnescapeSlow() [2/2]

template<typename Char >

MaybeHandle<String> v8::internal::URIUnescape::UnescapeSlow	(	Isolate *	isolate,
		Handle< String >	string,
		int	start_index
	)

Definition at line 84 of file runtime-uri.cc.

                                                               {
  bool one_byte = true;
  int length = string->length();
 
  int unescaped_length = 0;
  {
    DisallowHeapAllocation no_allocation;
    Vector<const Char> vector = GetCharVector<Char>(string);
    for (int i = start_index; i < length; unescaped_length++) {
      int step;
      if (UnescapeChar(vector, i, length, &step) >
          String::kMaxOneByteCharCode) {
        one_byte = false;
      }
      i += step;
    }
  }
 
  DCHECK(start_index < length);
  Handle<String> first_part =
      isolate->factory()->NewProperSubString(string, 0, start_index);
 
  int dest_position = 0;
  Handle<String> second_part;
  DCHECK(unescaped_length <= String::kMaxLength);
  if (one_byte) {
    Handle<SeqOneByteString> dest = isolate->factory()
                                        ->NewRawOneByteString(unescaped_length)
                                        .ToHandleChecked();
    DisallowHeapAllocation no_allocation;
    Vector<const Char> vector = GetCharVector<Char>(string);
    for (int i = start_index; i < length; dest_position++) {
      int step;
      dest->SeqOneByteStringSet(dest_position,
                                UnescapeChar(vector, i, length, &step));
      i += step;
    }
    second_part = dest;
  } else {
    Handle<SeqTwoByteString> dest = isolate->factory()
                                        ->NewRawTwoByteString(unescaped_length)
                                        .ToHandleChecked();
    DisallowHeapAllocation no_allocation;
    Vector<const Char> vector = GetCharVector<Char>(string);
    for (int i = start_index; i < length; dest_position++) {
      int step;
      dest->SeqTwoByteStringSet(dest_position,
                                UnescapeChar(vector, i, length, &step));
      i += step;
    }
    second_part = dest;
  }
  return isolate->factory()->NewConsString(first_part, second_part);
}

References DCHECK, v8::internal::Isolate::factory(), v8::internal::String::kMaxLength, and v8::internal::String::kMaxOneByteCharCode.

Here is the call graph for this function:

Member Data Documentation

kHexValue

const signed char v8::internal::URIUnescape::kHexValue

staticprivate

Initial value:

= {
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -0, 1,  2,  3,  4,  5,
    6,  7,  8,  9,  -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15}

Definition at line 45 of file runtime-uri.cc.

---

The documentation for this class was generated from the following file:

• /mnt/V8SourceCode/src/runtime/runtime-uri.cc