Lines Matching defs:at
139 // at a time, which is not always enough to pay for the extra logic.
157 // We declare a regexp low-alphabet if it has at least 3 times as many
414 // If we had a compilation error the last time this is saved at the
755 ASSERT(registers_per_match_ >= 2); // Each match has at least one capture.
838 // if input string matches at current position
849 // at the point where they are needed by a recursive call to Emit(). If
863 // A choice node looks at the following character and eliminates some of
931 text->AddElement(elements()->at(i), zone);
1456 // Now that we have unwound the stack we find at the top of the stack the
1843 ASSERT_EQ(ranges->at(i) & ~kMask, base);
1845 ASSERT(start_index == 0 || (ranges->at(start_index - 1) & ~kMask) <= base);
1860 for (int i = 0; i < (ranges->at(start_index) & kMask) && i < kSize; i++) {
1866 for (j = (ranges->at(i) & kMask); j < (ranges->at(i + 1) & kMask); j++) {
1896 ranges->at(cut_index),
1897 ranges->at(cut_index + 1) - 1,
1906 ranges->at(j) = ranges->at(j - 1);
1909 ranges->at(j) = ranges->at(j + 1);
1925 int first = ranges->at(start_index);
1926 int last = ranges->at(end_index) - 1;
1929 *border = (ranges->at(start_index) & ~kMask) + kSize;
1931 if (ranges->at(*new_start_index) > *border) break;
1941 // wish to do binary chop search at a smaller granularity than that. A
1954 ranges->at(binary_chop_index) >= first + 2 * kSize) {
1956 int new_border = (ranges->at(binary_chop_index) | kMask) + 1;
1959 if (ranges->at(scan_forward_for_section_border) > new_border) {
1970 if (ranges->at(*new_end_index) == *border) {
1973 if (*border >= ranges->at(end_index)) {
1974 *border = ranges->at(end_index);
1996 int first = ranges->at(start_index);
1997 int last = ranges->at(end_index) - 1;
2024 if (ranges->at(i) == ranges->at(i + 1) - 1) {
2101 border == ranges->at(new_end_index + 1)));
2104 ASSERT_LT(ranges->at(new_end_index), border);
2105 ASSERT(border < ranges->at(new_start_index) ||
2106 (border == ranges->at(new_start_index) &&
2110 ASSERT(new_start_index == 0 || border >= ranges->at(new_start_index - 1));
2163 CharacterRange& range = ranges->at(last_valid_range);
2181 ranges->at(0).IsEverything(max_char)) {
2194 ranges->at(0).IsEverything(max_char)) {
2216 // entry at zero which goes to the failure label, but if there
2225 CharacterRange& range = ranges->at(i);
2235 if (range_boundaries->at(end_index) > max_char) {
2329 // If we know we are not at the start and we are asked "how many characters
2368 // We are not at start after this node so we set the last argument to 'true'.
2381 RegExpNode* node = alternatives_->at(1).node();
2393 RegExpNode* node = alternatives_->at(1).node();
2407 RegExpNode* node = alternatives_->at(i).node();
2563 TextElement elm = elms_->at(k);
2587 // a match at this character position.
2601 // whether we have a match at this character position. Otherwise
2612 // determine definitely whether we have a match at this character
2638 while (ranges->at(first_range).from() > char_mask) {
2646 CharacterRange range = ranges->at(first_range);
2662 CharacterRange range = ranges->at(i);
2803 if (RangeContainsLatin1Equivalents(ranges->at(i))) return true;
2816 TextElement elm = elms_->at(i);
2839 // Now they are in order so we only need to look at the first.
2843 ranges->at(0).from() == 0 &&
2844 ranges->at(0).to() >= String::kMaxOneByteCharCode) {
2851 ranges->at(0).from() > String::kMaxOneByteCharCode) {
2889 GuardedAlternative alternative = alternatives_->at(i);
2899 GuardedAlternative alternative = alternatives_->at(i);
2904 alternatives_->at(i).set_node(replacement);
2921 alternatives_->at(i).node()->FilterASCII(depth - 1, ignore_case);
2923 alternatives_->at(i).set_node(replacement);
2924 new_alternatives->Add(alternatives_->at(i), zone());
2940 RegExpNode* node = alternatives_->at(1).node();
2943 alternatives_->at(1).set_node(replacement);
2945 RegExpNode* neg_node = alternatives_->at(0).node();
2950 alternatives_->at(0).set_node(neg_replacement);
2989 alternatives_->at(0).node()->GetQuickCheckDetails(details,
2995 RegExpNode* node = alternatives_->at(i).node();
3044 // ok if we are at the start.
3047 // We already checked that we are not at the start of input so it must be
3081 if (bm->at(0)->is_non_word())
3083 if (bm->at(0)->is_word()) next_is_word_character = Trace::TRUE_VALUE;
3086 if (lookahead->at(0)->is_non_word())
3088 if (lookahead->at(0)->is_word())
3137 // decided if we are at the start.
3140 // We already checked that we are not at the start of input so it must be
3244 // or obviate the need for further checks at some character positions.
3258 TextElement elm = elms_->at(i);
3422 TextElement elm = elms_->at(i);
3431 ranges->at(j).AddCaseEquivalents(ranges, is_ascii, zone());
3439 TextElement elm = elms_->at(elms_->length() - 1);
3447 TextElement elm = elms_->at(0);
3464 return ranges->at(0).IsEverything(max_char) ? on_success() : NULL;
3513 GreedyLoopTextLengthForAlternative(&(alternatives_->at(0)));
3588 AlternativeGeneration* at(int i) {
3631 for (int i = 0; i < kMapSize; i++) map_->at(i) = true;
3637 if (!map_->at(mod_character)) {
3639 map_->at(mod_character) = true;
3650 for (int i = 0; i < kMapSize; i++) map_->at(i) = true;
3672 // characters that can occur at a given position. Since we are optimizing two
3673 // different parameters at once this is a tradeoff.
3692 // max_number_of_chars that can occur at this position. Calculates the number
3707 BoyerMoorePositionInfo* map = bitmaps_->at(i);
3708 for (int j = 0; j < kSize; j++) union_map[j] |= map->at(j);
3746 // character at max_lookahead offset is not one of these characters, then we
3762 BoyerMoorePositionInfo* map = bitmaps_->at(i);
3764 if (map->at(j)) {
3786 BoyerMoorePositionInfo* map = bitmaps_->at(i);
3793 if (map->at(j)) {
3926 GuardedAlternative alternative = alternatives_->at(i);
3930 ASSERT(!trace->mentions_reg(guards->at(j)->reg()));
3949 int text_length = GreedyLoopTextLengthForAlternative(&(alternatives_->at(0)));
3976 alternatives_->at(0).node()->Emit(compiler, &greedy_match_trace);
3992 GuardedAlternative alt1 = alternatives_->at(1);
3997 // At this point we know that we are at a non-greedy loop that will eat
3998 // any character one at a time. Any non-anchored regexp has such a
4016 GuardedAlternative alt0 = alternatives_->at(0);
4028 // Save some time by looking at most one machine word ahead.
4043 at(i);
4044 AlternativeGeneration* alt_gen = alt_gens.at(i);
4105 GenerateGuard(macro_assembler, guards->at(j), &new_trace);
4116 // Otherwise try the second priority at an earlier position.
4121 // At this point we need to generate slow checks for the alternatives where
4125 AlternativeGeneration* alt_gen = alt_gens.at(i);
4135 alternatives_->at(i),
4138 alt_gens.at(i + 1)->expects_preload);
4163 GenerateGuard(macro_assembler, guards->at(j), &out_of_line_trace);
4178 GenerateGuard(macro_assembler, guards->at(j), &out_of_line_trace);
4406 choice()->alternatives()->at(i).node());
4506 GuardedAlternative alt = that->alternatives()->at(i);
4511 GuardedAlternative alt = that->alternatives()->at(i);
4522 TextElement elm = that->elements()->at(i);
4534 CharacterRange range = node->ranges(zone)->at(j);
4716 CharacterRange range = ranges->at(0);
4724 range = ranges->at((i >> 1) + 1);
4745 CharacterRange range = ranges->at(i >> 1);
4809 GuardedAlternative alternative(alternatives->at(i)->ToNode(compiler,
5154 current = children->at(i)->ToNode(compiler, current);
5284 table.AddRange(base->at(i), CharacterRangeSplitter::kInBase, zone);
5316 // expanding contiguous subranges (blocks) one at a time.
5364 int max = ranges->at(0).to();
5366 CharacterRange next_range = ranges->at(i);
5392 list->at(to + i) = list->at(from + i);
5396 list->at(to + i) = list->at(from + i);
5406 // by from value and non-overlapping and non-adjacent, using at most
5415 CharacterRange current = list->at(i);
5424 // Inserted range overlaps, or is adjacent to, ranges at positions
5425 // [start_pos..end_pos[. Ranges before start_pos or at or after end_pos are
5432 at position start_pos.
5436 list->at(start_pos) = insert;
5440 // Replace single existing range at position start_pos.
5441 CharacterRange to_replace = list->at(start_pos);
5444 list->at(start_pos) = CharacterRange(new_from, new_to);
5450 int new_from = Min(list->at(start_pos).from(), from);
5451 int new_to = Max(list->at(end_pos - 1).to(), to);
5455 list->at(start_pos) = CharacterRange(new_from, new_to);
5473 int max = character_ranges->at(0).to();
5476 CharacterRange current = character_ranges->at(i);
5486 // The ranges at index i and forward are not canonicalized. Make them so by
5496 character_ranges->at(read));
5513 if (range_count > 0 && ranges->at(0).from() == 0) {
5514 from = ranges->at(0).to();
5518 CharacterRange range = ranges->at(i);
5539 OutSet* successor = successors(zone)->at(i);
5649 // Bail out if the last interval ended at 0xFFFF since otherwise
5710 TextElement& elm = elements()->at(i);
5742 RegExpNode* node = that->alternatives()->at(i).node();
5755 RegExpNode* node = that->alternatives()->at(i).node();
5803 GuardedAlternative& alt = alts->at(i);
5827 TextElement text = elements()->at(i);
5858 CharacterRange& range = ranges->at(k);
5874 true); // Not at start after a text node.
5893 alternatives->at(i).node()->Accept(this);
5947 CharacterRange range = ranges->at(i);
5963 TextElement elm = that->elements()->at(0);
5977 AddRange(ranges->at(i));
6030 // Add a .*? at the beginning, outside the body capture, unless
6031 // this expression is anchored at the beginning.
6043 // at the start of input.
