Lines Matching refs:isolate
42 HandleScope scope(isolate);
44 string = String::Flatten(isolate, string);
45 RETURN_RESULT_OR_FAILURE(isolate, Intl::ConvertToUpper(isolate, string));
49 HandleScope handle_scope(isolate);
50 isolate->CountUsage(v8::Isolate::UseCounterFeature::kStringNormalize);
53 Handle<Object> form_input = args.atOrUndefined(isolate, 1);
55 RETURN_RESULT_OR_FAILURE(isolate,
56 Intl::Normalize(isolate, string, form_input));
60 HandleScope scope(isolate);
61 Handle<Object> locales = args.atOrUndefined(isolate, 1);
62 Handle<Object> options = args.atOrUndefined(isolate, 2);
65 isolate, Intl::SupportedLocalesOf(
66 isolate, "Intl.v8BreakIterator.supportedLocalesOf",
71 HandleScope scope(isolate);
72 Handle<Object> locales = args.atOrUndefined(isolate, 1);
73 Handle<Object> options = args.atOrUndefined(isolate, 2);
76 isolate, Intl::SupportedLocalesOf(
77 isolate, "Intl.NumberFormat.supportedLocalesOf",
83 HandleScope handle_scope(isolate);
91 isolate, x,
92 Intl::ToIntlMathematicalValueAsNumberBigIntOrString(isolate, value));
94 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, x,
95 Object::ToNumeric(isolate, value));
98 x = isolate->factory()->nan_value();
102 isolate, JSNumberFormat::FormatToParts(isolate, number_format, x));
108 HandleScope scope(isolate);
114 isolate, date_time_format,
115 JSDateTimeFormat::UnwrapDateTimeFormat(isolate, format_holder));
118 isolate, JSDateTimeFormat::ResolvedOptions(isolate, date_time_format));
122 HandleScope scope(isolate);
123 Handle<Object> locales = args.atOrUndefined(isolate, 1);
124 Handle<Object> options = args.atOrUndefined(isolate, 2);
127 isolate, Intl::SupportedLocalesOf(
128 isolate, "Intl.DateTimeFormat.supportedLocalesOf",
134 HandleScope handle_scope(isolate);
136 Factory* factory = isolate->factory();
140 isolate, NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
147 Handle<Object> x = args.atOrUndefined(isolate, 1);
148 if (x->IsUndefined(isolate)) {
149 x = factory->NewNumber(JSDate::CurrentTimeValue(isolate));
151 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, x,
152 Object::ToNumber(isolate, args.at(1)));
158 isolate, NewRangeError(MessageTemplate::kInvalidTimeValue));
161 RETURN_RESULT_OR_FAILURE(isolate, JSDateTimeFormat::FormatToParts(
162 isolate, dtf, date_value, false));
169 BuiltinArguments args, Isolate* isolate, const char* const method_name) {
174 Factory* factory = isolate->factory();
180 isolate, NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
189 Handle<Object> start_date = args.atOrUndefined(isolate, 1);
190 Handle<Object> end_date = args.atOrUndefined(isolate, 2);
191 if (start_date->IsUndefined(isolate) || end_date->IsUndefined(isolate)) {
193 isolate, NewTypeError(MessageTemplate::kInvalidTimeValue));
196 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, start_date,
197 Object::ToNumber(isolate, start_date));
201 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, end_date,
202 Object::ToNumber(isolate, end_date));
207 isolate, NewRangeError(MessageTemplate::kInvalidTimeValue));
213 RETURN_RESULT_OR_FAILURE(isolate, F(isolate, dtf, x, y));
218 HandleScope handle_scope(isolate);
220 args, isolate, method_name);
226 HandleScope handle_scope(isolate);
228 args, isolate, method_name);
233 Handle<JSFunction> CreateBoundFunction(Isolate* isolate,
236 Handle<NativeContext> native_context(isolate->context().native_context(),
237 isolate);
238 Handle<Context> context = isolate->factory()->NewBuiltinContext(
246 isolate->factory()->NewSharedFunctionInfoForBuiltin(
247 isolate->factory()->empty_string(), builtin,
252 return Factory::JSFunctionBuilder{isolate, info, context}
253 .set_map(isolate->strict_function_without_prototype_map())
262 Object LegacyFormatConstructor(BuiltinArguments args, Isolate* isolate,
266 isolate->CountUsage(feature);
270 if (args.new_target()->IsUndefined(isolate)) {
278 Handle<Object> locales = args.atOrUndefined(isolate, 1);
279 Handle<Object> options = args.atOrUndefined(isolate, 2);
285 isolate, map, JSFunction::GetDerivedMap(isolate, target, new_target));
290 isolate, format, T::New(isolate, map, locales, options, method_name));
292 if (args.new_target()->IsUndefined(isolate)) {
299 isolate, ordinary_has_instance_obj,
300 Object::OrdinaryHasInstance(isolate, constructor, receiver));
301 if (ordinary_has_instance_obj->BooleanValue(isolate)) {
304 isolate, NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
305 isolate->factory()->NewStringFromAsciiChecked(
319 isolate, rec, isolate->factory()->intl_fallback_symbol(), &desc,
321 MAYBE_RETURN(success, ReadOnlyRoots(isolate).exception());
336 Object DisallowCallConstructor(BuiltinArguments args, Isolate* isolate,
339 isolate->CountUsage(feature);
342 if (args.new_target()->IsUndefined(isolate)) { // [[Call]]
344 isolate, NewTypeError(MessageTemplate::kConstructorNotFunction,
345 isolate->factory()->NewStringFromAsciiChecked(
356 isolate, map, JSFunction::GetDerivedMap(isolate, target, new_target));
358 Handle<Object> locales = args.atOrUndefined(isolate, 1);
359 Handle<Object> options = args.atOrUndefined(isolate, 2);
362 RETURN_RESULT_OR_FAILURE(isolate, T::New(isolate, map, locales, options));
369 Object CallOrConstructConstructor(BuiltinArguments args, Isolate* isolate,
373 if (args.new_target()->IsUndefined(isolate)) {
382 Handle<Object> locales = args.atOrUndefined(isolate, 1);
383 Handle<Object> options = args.atOrUndefined(isolate, 2);
387 isolate, map, JSFunction::GetDerivedMap(isolate, target, new_target));
389 RETURN_RESULT_OR_FAILURE(isolate,
390 T::New(isolate, map, locales, options, method_name));
398 HandleScope scope(isolate);
401 args, isolate, v8::Isolate::UseCounterFeature::kDisplayNames,
406 HandleScope scope(isolate);
409 return *JSDisplayNames::ResolvedOptions(isolate, holder);
413 HandleScope scope(isolate);
414 Handle<Object> locales = args.atOrUndefined(isolate, 1);
415 Handle<Object> options = args.atOrUndefined(isolate, 2);
418 isolate, Intl::SupportedLocalesOf(
419 isolate, "Intl.DisplayNames.supportedLocalesOf",
424 HandleScope scope(isolate);
426 Handle<Object> code_obj = args.atOrUndefined(isolate, 1);
428 RETURN_RESULT_OR_FAILURE(isolate,
429 JSDisplayNames::Of(isolate, holder, code_obj));
435 HandleScope scope(isolate);
438 args, isolate, v8::Isolate::UseCounterFeature::kNumberFormat,
439 isolate->intl_number_format_function(), "Intl.NumberFormat");
443 HandleScope scope(isolate);
453 isolate, number_format,
454 JSNumberFormat::UnwrapNumberFormat(isolate, number_format_holder));
456 return *JSNumberFormat::ResolvedOptions(isolate, number_format);
461 HandleScope scope(isolate);
470 isolate, number_format,
471 JSNumberFormat::UnwrapNumberFormat(isolate, receiver));
473 Handle<Object> bound_format(number_format->bound_format(), isolate);
476 if (!bound_format->IsUndefined(isolate)) {
483 isolate, number_format, Builtin::kNumberFormatInternalFormatNumber, 1);
493 HandleScope scope(isolate);
495 Handle<Context> context = Handle<Context>(isolate->context(), isolate);
503 isolate);
506 Handle<Object> value = args.atOrUndefined(isolate, 1);
512 isolate, numeric_obj,
513 Intl::ToIntlMathematicalValueAsNumberBigIntOrString(isolate, value));
515 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, numeric_obj,
516 Object::ToNumeric(isolate, value));
525 isolate, JSNumberFormat::FormatNumeric(
526 isolate, *icu_localized_number_formatter, numeric_obj));
533 Isolate* isolate,
539 Handle<Object> start = args.atOrUndefined(isolate, 1);
540 Handle<Object> end = args.atOrUndefined(isolate, 2);
542 Factory* factory = isolate->factory();
544 if (start->IsUndefined(isolate)) {
546 isolate,
550 if (end->IsUndefined(isolate)) {
552 isolate, NewTypeError(MessageTemplate::kInvalid,
559 isolate, x,
560 Intl::ToIntlMathematicalValueAsNumberBigIntOrString(isolate, start));
565 isolate, y,
566 Intl::ToIntlMathematicalValueAsNumberBigIntOrString(isolate, end));
568 RETURN_RESULT_OR_FAILURE(isolate, F(isolate, nf, x, y));
573 HandleScope handle_scope(isolate);
575 args, isolate, method_name);
581 HandleScope handle_scope(isolate);
583 args, isolate, method_name);
587 HandleScope scope(isolate);
590 args, isolate, v8::Isolate::UseCounterFeature::kDateTimeFormat,
591 isolate->intl_date_time_format_function(), "Intl.DateTimeFormat");
596 HandleScope scope(isolate);
605 isolate, format,
606 JSDateTimeFormat::UnwrapDateTimeFormat(isolate, receiver));
608 Handle<Object> bound_format = Handle<Object>(format->bound_format(), isolate);
611 if (!bound_format->IsUndefined(isolate)) {
618 isolate, format, Builtin::kDateTimeFormatInternalFormat, 1);
628 HandleScope scope(isolate);
629 Handle<Context> context = Handle<Context>(isolate->context(), isolate);
637 isolate);
639 Handle<Object> date = args.atOrUndefined(isolate, 1);
641 RETURN_RESULT_OR_FAILURE(isolate, JSDateTimeFormat::DateTimeFormat(
642 isolate, date_format_holder, date));
646 HandleScope scope(isolate);
647 Handle<Object> locales = args.atOrUndefined(isolate, 1);
649 RETURN_RESULT_OR_FAILURE(isolate,
650 Intl::GetCanonicalLocales(isolate, locales));
654 HandleScope scope(isolate);
655 Handle<Object> locales = args.atOrUndefined(isolate, 1);
657 RETURN_RESULT_OR_FAILURE(isolate, Intl::SupportedValuesOf(isolate, locales));
661 HandleScope scope(isolate);
664 args, isolate, v8::Isolate::UseCounterFeature::kListFormat,
669 HandleScope scope(isolate);
672 return *JSListFormat::ResolvedOptions(isolate, format_holder);
676 HandleScope scope(isolate);
677 Handle<Object> locales = args.atOrUndefined(isolate, 1);
678 Handle<Object> options = args.atOrUndefined(isolate, 2);
681 isolate, Intl::SupportedLocalesOf(
682 isolate, "Intl.ListFormat.supportedLocalesOf",
688 HandleScope scope(isolate);
690 isolate->CountUsage(v8::Isolate::UseCounterFeature::kLocale);
693 if (args.new_target()->IsUndefined(isolate)) { // [[Call]]
695 isolate, NewTypeError(MessageTemplate::kConstructorNotFunction,
696 isolate->factory()->NewStringFromAsciiChecked(
703 Handle<Object> tag = args.atOrUndefined(isolate, 1);
704 Handle<Object> options = args.atOrUndefined(isolate, 2);
710 isolate, map, JSFunction::GetDerivedMap(isolate, target, new_target));
715 isolate, NewTypeError(MessageTemplate::kLocaleNotEmpty));
723 locale_string = JSLocale::ToString(isolate, Handle<JSLocale>::cast(tag));
726 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, locale_string,
727 Object::ToString(isolate, tag));
733 isolate, options_object,
734 CoerceOptionsToObject(isolate, options, method_name));
737 isolate, JSLocale::New(isolate, map, locale_string, options_object));
741 HandleScope scope(isolate);
743 RETURN_RESULT_OR_FAILURE(isolate, JSLocale::Maximize(isolate, locale));
747 HandleScope scope(isolate);
749 RETURN_RESULT_OR_FAILURE(isolate, JSLocale::Minimize(isolate, locale));
753 HandleScope scope(isolate);
755 RETURN_RESULT_OR_FAILURE(isolate, JSLocale::Calendars(isolate, locale));
759 HandleScope scope(isolate);
761 RETURN_RESULT_OR_FAILURE(isolate, JSLocale::Collations(isolate, locale));
765 HandleScope scope(isolate);
767 RETURN_RESULT_OR_FAILURE(isolate, JSLocale::HourCycles(isolate, locale));
771 HandleScope scope(isolate);
773 RETURN_RESULT_OR_FAILURE(isolate,
774 JSLocale::NumberingSystems(isolate, locale));
778 HandleScope scope(isolate);
780 RETURN_RESULT_OR_FAILURE(isolate, JSLocale::TextInfo(isolate, locale));
784 HandleScope scope(isolate);
786 RETURN_RESULT_OR_FAILURE(isolate, JSLocale::TimeZones(isolate, locale));
790 HandleScope scope(isolate);
792 RETURN_RESULT_OR_FAILURE(isolate, JSLocale::WeekInfo(isolate, locale));
796 HandleScope scope(isolate);
797 Handle<Object> locales = args.atOrUndefined(isolate, 1);
798 Handle<Object> options = args.atOrUndefined(isolate, 2);
801 isolate,
803 isolate, "Intl.RelativeTimeFormat.supportedLocalesOf",
808 HandleScope scope(isolate);
815 Handle<Object> value_obj = args.atOrUndefined(isolate, 1);
816 Handle<Object> unit_obj = args.atOrUndefined(isolate, 2);
819 isolate, JSRelativeTimeFormat::Format(isolate, value_obj, unit_obj,
824 HandleScope scope(isolate);
831 Handle<Object> value_obj = args.atOrUndefined(isolate, 1);
832 Handle<Object> unit_obj = args.atOrUndefined(isolate, 2);
834 isolate, JSRelativeTimeFormat::FormatToParts(isolate, value_obj, unit_obj,
840 HandleScope scope(isolate);
844 return *JSLocale::Language(isolate, locale);
848 HandleScope scope(isolate);
851 return *JSLocale::Script(isolate, locale);
855 HandleScope scope(isolate);
858 return *JSLocale::Region(isolate, locale);
862 HandleScope scope(isolate);
865 return *JSLocale::BaseName(isolate, locale);
869 HandleScope scope(isolate);
872 return *JSLocale::Calendar(isolate, locale);
876 HandleScope scope(isolate);
879 return *JSLocale::CaseFirst(isolate, locale);
883 HandleScope scope(isolate);
886 return *JSLocale::Collation(isolate, locale);
890 HandleScope scope(isolate);
893 return *JSLocale::HourCycle(isolate, locale);
897 HandleScope scope(isolate);
900 return *JSLocale::Numeric(isolate, locale);
904 HandleScope scope(isolate);
907 return *JSLocale::NumberingSystem(isolate, locale);
911 HandleScope scope(isolate);
914 return *JSLocale::ToString(isolate, locale);
918 HandleScope scope(isolate);
921 args, isolate, v8::Isolate::UseCounterFeature::kRelativeTimeFormat,
926 HandleScope scope(isolate);
929 return *JSRelativeTimeFormat::ResolvedOptions(isolate, format_holder);
933 HandleScope scope(isolate);
935 isolate->CountUsage(v8::Isolate::UseCounterFeature::kStringToLocaleLowerCase);
940 isolate, Intl::StringLocaleConvertCase(isolate, string, false,
941 args.atOrUndefined(isolate, 1)));
945 HandleScope scope(isolate);
947 isolate->CountUsage(v8::Isolate::UseCounterFeature::kStringToLocaleUpperCase);
952 isolate, Intl::StringLocaleConvertCase(isolate, string, true,
953 args.atOrUndefined(isolate, 1)));
957 HandleScope scope(isolate);
960 args, isolate, v8::Isolate::UseCounterFeature::kPluralRules,
965 HandleScope scope(isolate);
968 return *JSPluralRules::ResolvedOptions(isolate, plural_rules_holder);
972 HandleScope scope(isolate);
980 Handle<Object> number = args.atOrUndefined(isolate, 1);
981 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, number,
982 Object::ToNumber(isolate, number));
986 RETURN_RESULT_OR_FAILURE(isolate, JSPluralRules::ResolvePlural(
987 isolate, plural_rules, number_double));
991 HandleScope scope(isolate);
999 Handle<Object> start = args.atOrUndefined(isolate, 1);
1000 Handle<Object> end = args.atOrUndefined(isolate, 2);
1003 isolate, NewTypeError(MessageTemplate::kInvalid,
1004 isolate->factory()->startRange_string(), start));
1008 isolate, NewTypeError(MessageTemplate::kInvalid,
1009 isolate->factory()->endRange_string(), end));
1014 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, x,
1015 Object::ToNumber(isolate, start));
1019 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, y,
1020 Object::ToNumber(isolate, end));
1027 isolate, NewRangeError(MessageTemplate::kInvalid,
1028 isolate->factory()->startRange_string(), x));
1032 isolate, NewRangeError(MessageTemplate::kInvalid,
1033 isolate->factory()->endRange_string(), y));
1041 isolate, NewRangeError(MessageTemplate::kInvalid, x, y));
1044 isolate, JSPluralRules::ResolvePluralRange(isolate, plural_rules,
1049 HandleScope scope(isolate);
1050 Handle<Object> locales = args.atOrUndefined(isolate, 1);
1051 Handle<Object> options = args.atOrUndefined(isolate, 2);
1054 isolate, Intl::SupportedLocalesOf(
1055 isolate, "Intl.PluralRules.supportedLocalesOf",
1060 HandleScope scope(isolate);
1062 isolate->CountUsage(v8::Isolate::UseCounterFeature::kCollator);
1064 return CallOrConstructConstructor<JSCollator>(args, isolate, "Intl.Collator");
1068 HandleScope scope(isolate);
1071 return *JSCollator::ResolvedOptions(isolate, collator_holder);
1075 HandleScope scope(isolate);
1076 Handle<Object> locales = args.atOrUndefined(isolate, 1);
1077 Handle<Object> options = args.atOrUndefined(isolate, 2);
1080 isolate, Intl::SupportedLocalesOf(
1081 isolate, "Intl.Collator.supportedLocalesOf",
1087 HandleScope scope(isolate);
1096 Handle<Object> bound_compare(collator->bound_compare(), isolate);
1097 if (!bound_compare->IsUndefined(isolate)) {
1104 isolate, collator, Builtin::kCollatorInternalCompare, 2);
1114 HandleScope scope(isolate);
1115 Handle<Context> context = Handle<Context>(isolate->context(), isolate);
1123 isolate);
1126 Handle<Object> x = args.atOrUndefined(isolate, 1);
1128 Handle<Object> y = args.atOrUndefined(isolate, 2);
1132 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, string_x,
1133 Object::ToString(isolate, x));
1136 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, string_y,
1137 Object::ToString(isolate, y));
1143 Intl::CompareStrings(isolate, *icu_collator, string_x, string_y));
1149 HandleScope scope(isolate);
1152 RETURN_RESULT_OR_FAILURE(isolate,
1153 JSSegmentIterator::Next(isolate, segment_iterator));
1158 HandleScope scope(isolate);
1161 args, isolate, v8::Isolate::UseCounterFeature::kSegmenter,
1167 HandleScope scope(isolate);
1168 Handle<Object> locales = args.atOrUndefined(isolate, 1);
1169 Handle<Object> options = args.atOrUndefined(isolate, 2);
1172 isolate, Intl::SupportedLocalesOf(
1173 isolate, "Intl.Segmenter.supportedLocalesOf",
1179 HandleScope scope(isolate);
1182 return *JSSegmenter::ResolvedOptions(isolate, segmenter);
1187 HandleScope scope(isolate);
1189 Handle<Object> input_text = args.atOrUndefined(isolate, 1);
1192 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, string,
1193 Object::ToString(isolate, input_text));
1196 RETURN_RESULT_OR_FAILURE(isolate,
1197 JSSegments::Create(isolate, segmenter, string));
1203 HandleScope scope(isolate);
1205 Handle<Object> index = args.atOrUndefined(isolate, 1);
1208 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, index,
1209 Object::ToInteger(isolate, index));
1212 RETURN_RESULT_OR_FAILURE(isolate,
1213 JSSegments::Containing(isolate, segments, n));
1219 HandleScope scope(isolate);
1222 isolate,
1223 JSSegmentIterator::Create(isolate, segments->icu_break_iterator().raw(),
1228 HandleScope scope(isolate);
1230 return CallOrConstructConstructor<JSV8BreakIterator>(args, isolate,
1235 HandleScope scope(isolate);
1238 return *JSV8BreakIterator::ResolvedOptions(isolate, break_iterator);
1244 HandleScope scope(isolate);
1248 Handle<Object> bound_adopt_text(break_iterator->bound_adopt_text(), isolate);
1249 if (!bound_adopt_text->IsUndefined(isolate)) {
1255 isolate, break_iterator, Builtin::kV8BreakIteratorInternalAdoptText, 1);
1261 HandleScope scope(isolate);
1262 Handle<Context> context = Handle<Context>(isolate->context(), isolate);
1267 isolate);
1269 Handle<Object> input_text = args.atOrUndefined(isolate, 1);
1271 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, text,
1272 Object::ToString(isolate, input_text));
1274 JSV8BreakIterator::AdoptText(isolate, break_iterator, text);
1275 return ReadOnlyRoots(isolate).undefined_value();
1280 HandleScope scope(isolate);
1284 Handle<Object> bound_first(break_iterator->bound_first(), isolate);
1285 if (!bound_first->IsUndefined(isolate)) {
1291 isolate, break_iterator, Builtin::kV8BreakIteratorInternalFirst, 0);
1297 HandleScope scope(isolate);
1298 Handle<Context> context = Handle<Context>(isolate->context(), isolate);
1303 isolate);
1305 return *JSV8BreakIterator::First(isolate, break_iterator);
1310 HandleScope scope(isolate);
1314 Handle<Object> bound_next(break_iterator->bound_next(), isolate);
1315 if (!bound_next->IsUndefined(isolate)) {
1321 isolate, break_iterator, Builtin::kV8BreakIteratorInternalNext, 0);
1327 HandleScope scope(isolate);
1328 Handle<Context> context = Handle<Context>(isolate->context(), isolate);
1333 isolate);
1334 return *JSV8BreakIterator::Next(isolate, break_iterator);
1339 HandleScope scope(isolate);
1343 Handle<Object> bound_current(break_iterator->bound_current(), isolate);
1344 if (!bound_current->IsUndefined(isolate)) {
1350 isolate, break_iterator, Builtin::kV8BreakIteratorInternalCurrent, 0);
1356 HandleScope scope(isolate);
1357 Handle<Context> context = Handle<Context>(isolate->context(), isolate);
1362 isolate);
1363 return *JSV8BreakIterator::Current(isolate, break_iterator);
1369 HandleScope scope(isolate);
1373 Handle<Object> bound_break_type(break_iterator->bound_break_type(), isolate);
1374 if (!bound_break_type->IsUndefined(isolate)) {
1380 isolate, break_iterator, Builtin::kV8BreakIteratorInternalBreakType, 0);
1386 HandleScope scope(isolate);
1387 Handle<Context> context = Handle<Context>(isolate->context(), isolate);
1392 isolate);
1393 return JSV8BreakIterator::BreakType(isolate, break_iterator);