Lines Matching defs:ranges
50 bool CompareInverseRanges(ZoneList<CharacterRange>* ranges,
55 DCHECK_NE(0, ranges->length());
59 if (ranges->length() != (length >> 1) + 1) return false;
61 CharacterRange range = ranges->at(0);
68 range = ranges->at((i >> 1) + 1);
77 bool CompareRanges(ZoneList<CharacterRange>* ranges, const int* special_class,
82 if (ranges->length() * 2 != length) return false;
85 CharacterRange range = ranges->at(i >> 1);
105 if (CompareRanges(set_.ranges(zone), kSpaceRanges, kSpaceRangeCount)) {
109 if (CompareInverseRanges(set_.ranges(zone), kSpaceRanges, kSpaceRangeCount)) {
113 if (CompareInverseRanges(set_.ranges(zone), kLineTerminatorRanges,
118 if (CompareRanges(set_.ranges(zone), kLineTerminatorRanges,
123 if (CompareRanges(set_.ranges(zone), kWordRanges, kWordRangeCount)) {
127 if (CompareInverseRanges(set_.ranges(zone), kWordRanges, kWordRangeCount)) {
135 // The unicode range splitter categorizes given character ranges into:
247 // twice. We also create a dedicated grouping for full trailing ranges, i.e.
269 // First, create the grouped ranges.
306 // Create the actual TextNode now that ranges are fully grouped.
422 void AddUnicodeCaseEquivalents(ZoneList<CharacterRange>* ranges, Zone* zone) {
424 DCHECK(CharacterRange::IsCanonical(ranges));
426 // Micro-optimization to avoid passing large ranges to UnicodeSet::closeOver.
429 // which we use frequently internally. But large ranges can also easily be
431 // for such ranges.
432 if (ranges->length() == 1 && ranges->at(0).IsEverything(kNonBmpEnd)) return;
434 // Use ICU to compute the case fold closure over the ranges.
436 for (int i = 0; i < ranges->length(); i++) {
437 set.add(ranges->at(i).from(), ranges->at(i).to());
439 // Clear the ranges list without freeing the backing store.
440 ranges->Rewind(0);
447 ranges->Add(CharacterRange::Range(set.getRangeStart(i), set.getRangeEnd(i)),
450 // No errors and everything we collected have been ranges.
451 CharacterRange::Canonicalize(ranges);
461 ZoneList<CharacterRange>* ranges = this->ranges(zone);
464 AddUnicodeCaseEquivalents(ranges, zone);
475 CharacterRange::Negate(ranges, negated, zone);
476 ranges = negated;
479 if (ranges->length() == 0) {
481 RegExpCharacterClass* fail = zone->New<RegExpCharacterClass>(zone, ranges);
490 // Split ranges in order to handle surrogates correctly:
496 UnicodeRangeSplitter splitter(ranges);
503 if (ranges->length() > kMaxRangesToInline) result->SetDoNotInline();
795 ZoneList<CharacterRange>* ranges =
800 ranges->Add(CharacterRange::Singleton(old_atom->data().at(0)), zone);
807 zone->New<RegExpCharacterClass>(zone, ranges, character_class_flags);
1111 ZoneList<CharacterRange>* ranges =
1113 RegExpCharacterClass* cc = zone_->New<RegExpCharacterClass>(zone_, ranges);
1154 void AddClass(const int* elmv, int elmc, ZoneList<CharacterRange>* ranges,
1160 ranges->Add(CharacterRange::Range(elmv[i], elmv[i + 1] - 1), zone);
1165 ZoneList<CharacterRange>* ranges, Zone* zone) {
1174 ranges->Add(CharacterRange::Range(last, elmv[i] - 1), zone);
1177 ranges->Add(CharacterRange::Range(last, kMaxCodePoint), zone);
1183 ZoneList<CharacterRange>* ranges,
1202 ranges->AddAll(*new_ranges, zone);
1208 AddClass(kSpaceRanges, kSpaceRangeCount, ranges, zone);
1211 AddClassNegated(kSpaceRanges, kSpaceRangeCount, ranges, zone);
1214 AddClass(kWordRanges, kWordRangeCount, ranges, zone);
1217 AddClassNegated(kWordRanges, kWordRangeCount, ranges, zone);
1220 AddClass(kDigitRanges, kDigitRangeCount, ranges, zone);
1223 AddClassNegated(kDigitRanges, kDigitRangeCount, ranges, zone);
1228 AddClass(kLineTerminatorRanges, kLineTerminatorRangeCount, ranges, zone);
1231 AddClassNegated(kLineTerminatorRanges, kLineTerminatorRangeCount, ranges,
1238 ranges->Add(CharacterRange::Everything(), zone);
1245 ZoneList<CharacterRange>* ranges,
1247 CharacterRange::Canonicalize(ranges);
1248 int range_count = ranges->length();
1252 CharacterRange range = ranges->at(i);
1283 // Add others to the ranges
1288 ranges->Add(CharacterRange::Singleton(from), zone);
1290 ranges->Add(CharacterRange::Range(from, to), zone);
1295 CharacterRange range = ranges->at(i);
1312 ranges->Add(CharacterRange::Singleton(chars[i]), zone);
1352 ranges->Add(CharacterRange::Range(range_from, range_to), zone);
1362 bool CharacterRange::IsCanonical(ZoneList<CharacterRange>* ranges) {
1363 DCHECK_NOT_NULL(ranges);
1364 int n = ranges->length();
1366 base::uc32 max = ranges->at(0).to();
1368 CharacterRange next_range = ranges->at(i);
1375 ZoneList<CharacterRange>* CharacterSet::ranges(Zone* zone) {
1406 // canonicalized ranges. Inserting a range may collapse existing ranges into
1407 // fewer ranges, so the return value can be anything in the range 1..count+1.
1422 // Inserted range overlaps, or is adjacent to, ranges at positions
1430 // Insert between existing ranges at position start_pos.
1445 // Replace a number of existing ranges from start_pos to end_pos - 1.
1446 // Move the remaining ranges down.
1461 // of calling ranges() will be sorted.
1469 // Check whether ranges are already canonical (increasing, non-overlapping,
1485 // The ranges at index i and forward are not canonicalized. Make them so by
1488 // Notice that inserting a range can reduce the number of ranges in the
1489 // result due to combining of adjacent and overlapping ranges.
1503 void CharacterRange::Negate(ZoneList<CharacterRange>* ranges,
1506 DCHECK(CharacterRange::IsCanonical(ranges));
1508 int range_count = ranges->length();
1511 if (range_count > 0 && ranges->at(0).from() == 0) {
1512 from = ranges->at(0).to() + 1;
1516 CharacterRange range = ranges->at(i);
1527 void CharacterRange::ClampToOneByte(ZoneList<CharacterRange>* ranges) {
1528 DCHECK(IsCanonical(ranges));
1530 // Drop all ranges that don't contain one-byte code units, and clamp the last
1532 // on `ranges` being canonicalized, i.e. sorted and non-overlapping.
1535 int n = ranges->length();
1537 CharacterRange& r = ranges->at(n - 1);
1544 ranges->Rewind(n);