Lines Matching defs:character
143 void matchCharacterClassRange(RegisterID character, JumpList& failures, JumpList& matchDest, const CharacterRange* ranges, unsigned count, unsigned* matchIndex, const UChar* matches, unsigned matchCount)
154 Jump loOrAbove = branch32(GreaterThanOrEqual, character, Imm32((unsigned short)lo));
158 matchCharacterClassRange(character, failures, matchDest, ranges, which, matchIndex, matches, matchCount);
161 matchDest.append(branch32(Equal, character, Imm32((unsigned short)matches[*matchIndex])));
168 Jump loOrAbove = branch32(GreaterThanOrEqual, character, Imm32((unsigned short)lo));
170 matchCharacterClassRange(character, failures, matchDest, ranges, which, matchIndex, matches, matchCount);
175 failures.append(branch32(LessThan, character, Imm32((unsigned short)lo)));
180 matchDest.append(branch32(LessThanOrEqual, character, Imm32((unsigned short)hi)));
190 void matchCharacterClass(RegisterID character, JumpList& matchDest, const CharacterClass* charClass)
193 ExtendedAddress tableEntry(character, reinterpret_cast<intptr_t>(charClass->m_table));
199 Jump isAscii = branch32(LessThanOrEqual, character, TrustedImm32(0x7f));
204 matchDest.append(branch32(Equal, character, Imm32(ch)));
213 Jump below = branch32(LessThan, character, Imm32(lo));
214 matchDest.append(branch32(LessThanOrEqual, character, Imm32(hi)));
226 matchCharacterClassRange(character, failures, matchDest, charClass->m_ranges.begin(), charClass->m_ranges.size(), &matchIndex, charClass->m_matches.begin(), charClass->m_matches.size());
228 matchDest.append(branch32(Equal, character, Imm32((unsigned short)charClass->m_matches[matchIndex++])));
245 matchDest.append(branch32(Equal, character, Imm32((unsigned short)ch)));
249 or32(TrustedImm32(32), character);
251 matchDest.append(branch32(Equal, character, TrustedImm32(matchesAZaz[i])));
288 Jump jumpIfCharNotEquals(UChar ch, int inputPosition, RegisterID character)
290 readCharacter(inputPosition, character);
293 // upper & lower case representations are converted to a character class.
296 or32(TrustedImm32(0x20), character);
300 return branch32(NotEqual, character, Imm32(ch));
436 // Wraps all simple terms (pattern characters, character classes).
484 // This flag is used to null out the second pattern character, when
637 const RegisterID character = regT0;
643 readCharacter((term->inputPosition - m_checked) - 1, character);
644 matchCharacterClass(character, matchDest, m_pattern.newlineCharacterClass());
667 const RegisterID character = regT0;
673 readCharacter(term->inputPosition - m_checked, character);
674 matchCharacterClass(character, matchDest, m_pattern.newlineCharacterClass());
697 const RegisterID character = regT0;
702 readCharacter((term->inputPosition - m_checked), character);
703 matchCharacterClass(character, nextIsWordChar, m_pattern.wordcharCharacterClass());
711 const RegisterID character = regT0;
717 readCharacter((term->inputPosition - m_checked) - 1, character);
718 matchCharacterClass(character, matchDest, m_pattern.wordcharCharacterClass());
722 // We fall through to here if the last character was not a wordchar.
734 // We jump here if the last character was a wordchar.
772 // Have a 16 bit pattern character and an 8 bit string - short circuit
777 const RegisterID character = regT0;
789 // upper & lower case representations are converted to a character class.
819 // Have a 16 bit pattern character and an 8 bit string - short circuit
825 // upper & lower case representations are converted to a character class.
837 op.m_jumps.append(jumpIfCharNotEquals(ch, startTermPosition - m_checked, character));
841 load16Unaligned(address, character);
846 load16Unaligned(highAddress, character);
848 or32(Imm32(ignoreCaseMask), character);
849 op.m_jumps.append(branch32(NotEqual, character, Imm32((allCharacters & 0xffff) | ignoreCaseMask)));
850 op.m_jumps.append(jumpIfCharNotEquals(allCharacters >> 16, startTermPosition + 2 - m_checked, character));
855 load32WithUnalignedHalfWords(address, character);
862 op.m_jumps.append(jumpIfCharNotEquals(ch, term->inputPosition - m_checked, character));
866 load32WithUnalignedHalfWords(address, character);
872 or32(Imm32(ignoreCaseMask), character);
873 op.m_jumps.append(branch32(NotEqual, character, Imm32(allCharacters | ignoreCaseMask)));
887 const RegisterID character = regT0;
897 load8(address, character);
899 load16(address, character);
902 // upper & lower case representations are converted to a character class.
905 or32(TrustedImm32(0x20), character);
909 op.m_jumps.append(branch32(NotEqual, character, Imm32(ch)));
924 const RegisterID character = regT0;
929 // Unless have a 16 bit pattern character and an 8 bit string - short circuit
934 failures.append(jumpIfCharNotEquals(ch, term->inputPosition - m_checked, character));
982 const RegisterID character = regT0;
989 // Unless have a 16 bit pattern character and an 8 bit string - short circuit
995 nonGreedyFailures.append(jumpIfCharNotEquals(ch, term->inputPosition - m_checked, character));
1013 const RegisterID character = regT0;
1016 readCharacter(term->inputPosition - m_checked, character);
1017 matchCharacterClass(character, matchDest, term->characterClass);
1036 const RegisterID character = regT0;
1045 load8(BaseIndex(input, countRegister, TimesOne, (Checked<int>(term->inputPosition - m_checked + Checked<int64_t>(term->quantityCount)) * static_cast<int>(sizeof(char))).unsafeGet()), character);
1047 load16(BaseIndex(input, countRegister, TimesTwo, (Checked<int>(term->inputPosition - m_checked + Checked<int64_t>(term->quantityCount)) * static_cast<int>(sizeof(UChar))).unsafeGet()), character);
1048 matchCharacterClass(character, matchDest, term->characterClass);
1070 const RegisterID character = regT0;
1080 readCharacter(term->inputPosition - m_checked, character);
1081 matchCharacterClass(character, failures, term->characterClass);
1084 readCharacter(term->inputPosition - m_checked, character);
1085 matchCharacterClass(character, matchDest, term->characterClass);
1135 const RegisterID character = regT0;
1148 readCharacter(term->inputPosition - m_checked, character);
1149 matchCharacterClass(character, matchDest, term->characterClass);
1173 const RegisterID character = regT0;
1187 load8(BaseIndex(input, matchPos, TimesOne, 0), character);
1189 load16(BaseIndex(input, matchPos, TimesTwo, 0), character);
1190 matchCharacterClass(character, foundBeginningNewLine, m_pattern.newlineCharacterClass());
1209 load8(BaseIndex(input, matchPos, TimesOne, 0), character);
1211 load16(BaseIndex(input, matchPos, TimesTwo, 0), character);
1212 matchCharacterClass(character, foundEndingNewLine, m_pattern.newlineCharacterClass());
1230 // (pattern characters, character classes, and assertions).
1791 // character match of 'a'), then we need not perform an additional input availability
2693 // character 'b' within the regular expression /abc/, we will know that