Lines Matching defs:string
9 #include "src/string-builder.h"
10 #include "src/string-search.h"
16 // Perform string match of pattern on subject, starting at start index.
19 int StringMatch(Isolate* isolate, Handle<String> sub, Handle<String> pat,
30 sub = String::Flatten(sub);
31 pat = String::Flatten(pat);
35 String::FlatContent seq_sub = sub->GetFlatContent();
36 String::FlatContent seq_pat = pat->GetFlatContent();
59 MaybeHandle<String> StringReplaceOneCharWithString(
60 Isolate* isolate, Handle<String> subject, Handle<String> search,
61 Handle<String> replace, bool* found, int recursion_limit) {
64 return MaybeHandle<String>();
69 Handle<String> first = Handle<String>(cons->first());
70 Handle<String> second = Handle<String>(cons->second());
71 Handle<String> new_first;
74 return MaybeHandle<String>();
78 Handle<String> new_second;
82 return MaybeHandle<String>();
91 Handle<String> first = isolate->factory()->NewSubString(subject, 0, index);
92 Handle<String> cons1;
95 String);
96 Handle<String> second =
106 CONVERT_ARG_HANDLE_CHECKED(String, subject, 0);
107 CONVERT_ARG_HANDLE_CHECKED(String, search, 1);
108 CONVERT_ARG_HANDLE_CHECKED(String, replace, 2);
110 // If the cons string tree is too deep, we simply abort the recursion and
111 // retry with a flattened subject string.
114 Handle<String> result;
121 subject = String::Flatten(subject);
136 CONVERT_ARG_HANDLE_CHECKED(String, sub, 0);
137 CONVERT_ARG_HANDLE_CHECKED(String, pat, 1);
159 if (c > String::kMaxOneByteCharCode) {
187 CONVERT_ARG_HANDLE_CHECKED(String, sub, 0);
188 CONVERT_ARG_HANDLE_CHECKED(String, pat, 1);
205 sub = String::Flatten(sub);
206 pat = String::Flatten(pat);
211 String::FlatContent sub_content = sub->GetFlatContent();
212 String::FlatContent pat_content = pat->GetFlatContent();
242 CONVERT_ARG_HANDLE_CHECKED(String, str1, 0);
243 CONVERT_ARG_HANDLE_CHECKED(String, str2, 1);
261 // in each string, due to the trivial case handling above.
265 str1 = String::Flatten(str1);
266 str2 = String::Flatten(str2);
269 String::FlatContent flat1 = str1->GetFlatContent();
270 String::FlatContent flat2 = str2->GetFlatContent();
286 CONVERT_ARG_HANDLE_CHECKED(String, string, 0);
303 RUNTIME_ASSERT(end <= string->length());
306 return *isolate->factory()->NewSubString(string, start, end);
313 CONVERT_ARG_HANDLE_CHECKED(String, str1, 0);
314 CONVERT_ARG_HANDLE_CHECKED(String, str2, 1);
324 CONVERT_ARG_HANDLE_CHECKED(String, string, 0);
325 return *isolate->factory()->InternalizeString(string);
333 CONVERT_ARG_HANDLE_CHECKED(String, subject, 0);
366 Handle<String> substring =
372 Handle<String> substring =
386 CONVERT_ARG_HANDLE_CHECKED(String, subject, 0);
389 // Flatten the string. If someone wants to get a char at an index
390 // in a cons string, it is likely that more indices will be
392 subject = String::Flatten(subject);
405 CONVERT_ARG_HANDLE_CHECKED(String, x, 0);
406 CONVERT_ARG_HANDLE_CHECKED(String, y, 1);
408 switch (String::Compare(x, y)) {
431 CONVERT_ARG_HANDLE_CHECKED(String, special, 2);
439 DCHECK(Smi::kMaxValue >= String::kMaxLength);
501 CONVERT_ARG_HANDLE_CHECKED(String, separator, 2);
521 (String::kMaxLength + separator_length - 1) / separator_length;
529 String* element = String::cast(element_obj);
531 if (increment > String::kMaxLength - length) {
532 STATIC_ASSERT(String::kMaxLength < kMaxInt);
551 String* first = String::cast(fixed_array->get(0));
552 String* separator_raw = *separator;
555 String::WriteToFlat(first, sink, 0, first_length);
560 String::WriteToFlat(separator_raw, sink, 0, separator_length);
564 String* element = String::cast(fixed_array->get(i));
567 String::WriteToFlat(element, sink, 0, element_length);
578 static void WriteRepeatToFlat(String* src, Vector<sinkchar> buffer, int cursor,
583 String::WriteToFlat<sinkchar>(src, start, 0, length);
601 String* separator,
610 String* string = String::cast(elements->get(i + 1));
611 int string_length = string->length();
612 if (string->length() > 0) {
618 String::WriteToFlat<Char>(string, &buffer[cursor], 0, string_length);
619 cursor += string->length();
625 // otherwise the total string length would have been too large.
639 CONVERT_ARG_HANDLE_CHECKED(String, separator, 2);
644 // separator is string to put between elements. Assumed to be non-empty.
658 String* string = String::cast(elements->get(i + 1));
659 int length = string->length();
660 if (is_one_byte && !string->IsOneByteRepresentation()) {
663 if (length > String::kMaxLength ||
664 String::kMaxLength - length < string_length) {
676 int remaining_length = String::kMaxLength - string_length;
680 // Not room for the separators within the maximal string length.
685 // means that the string is too large to create.
686 STATIC_ASSERT(String::kMaxLength < 0x7fffffff);
691 // Throw an exception if the resulting string is too large. See
743 (element->IsString() && String::cast(element)->LooksValid()));
750 // Converts a String to JSArray.
755 CONVERT_ARG_HANDLE_CHECKED(String, s, 0);
758 s = String::Flatten(s);
768 String::FlatContent content = s->GetFlatContent();
790 DCHECK(String::cast(elements->get(i))->length() == 1);
809 Isolate* isolate, String* string, SeqString* result, int result_length,
825 StringCharacterStream stream(string);
827 // We can assume that the string is not empty
845 } else if (result_length == string->length()) {
853 // memcpy what we already have to the result string. Also,
854 // the result string is the last object allocated we could
856 // extend the existing string to be able to hold the full
874 if (current_length > String::kMaxLength) {
881 // to allocate a two-byte string for to uppercase.
897 // we simple return the result and let the converted string
900 return string;
1022 Handle<String> s, Isolate* isolate,
1024 s = String::Flatten(s);
1026 // Assume that the string is not empty; we need this assumption later
1040 String::FlatContent flat_content = s->GetFlatContent();
1078 CONVERT_ARG_HANDLE_CHECKED(String, s, 0);
1086 CONVERT_ARG_HANDLE_CHECKED(String, s, 0);
1093 CONVERT_ARG_HANDLE_CHECKED(String, x, 0);
1094 CONVERT_ARG_HANDLE_CHECKED(String, y, 1);
1095 switch (String::Compare(x, y)) {
1111 CONVERT_ARG_HANDLE_CHECKED(String, x, 0);
1112 CONVERT_ARG_HANDLE_CHECKED(String, y, 1);
1113 switch (String::Compare(x, y)) {
1129 CONVERT_ARG_HANDLE_CHECKED(String, x, 0);
1130 CONVERT_ARG_HANDLE_CHECKED(String, y, 1);
1131 switch (String::Compare(x, y)) {
1147 CONVERT_ARG_HANDLE_CHECKED(String, x, 0);
1148 CONVERT_ARG_HANDLE_CHECKED(String, y, 1);
1149 switch (String::Compare(x, y)) {
1165 CONVERT_ARG_HANDLE_CHECKED(String, x, 0);
1166 CONVERT_ARG_HANDLE_CHECKED(String, y, 1);
1167 return isolate->heap()->ToBoolean(String::Equals(x, y));
1173 CONVERT_ARG_HANDLE_CHECKED(String, x, 0);
1174 CONVERT_ARG_HANDLE_CHECKED(String, y, 1);
1175 return isolate->heap()->ToBoolean(!String::Equals(x, y));
1181 CONVERT_ARG_HANDLE_CHECKED(String, str, 0);
1182 return *String::Flatten(str);
1200 CONVERT_ARG_CHECKED(ExternalString, string, 0);
1202 return Smi::FromInt(string->Get(index));
