170:     needle = None

171:     needle_offset = None

540:     needles = []

59:         """Is the needle found at 'offset'?

63:             checked for the needle.

173:     def __init__(self, needle=None, needle_offset=0, **kwargs):

175:         self.needle = needle

176:         self.needle_offset = needle_offset

180:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset

181:         if buffer_as.data.startswith(self.needle, buffer_offset):

182:             return self.needle

185:         # Search the rest of the buffer for the needle.

186:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset

187:         dindex = buffer_as.data.find(self.needle, buffer_offset + 1)

532:             yield ("StringCheck", dict(needle=expected_bytes,

533:                                        needle_offset=rel_offset + array_offset))

553:                 needle=self.needles[0])

96:     def __init__(self, needles=None, **kwargs):

100:           needles: A list of strings we search for.

103:           RuntimeError: No needles provided.

109:         if not needles:

110:             raise RuntimeError("No needles provided to search.")

114:         if max([len(x) for x in needles]) > 50:

118:         # sure all the needles are bytes too.

119:         byte_needles = [utils.SmartStr(x) for x in needles]

120:         tree = acora.AcoraBuilder(*byte_needles)

539:     # Override with the needles to check for.

542:     def __init__(self, needles=None, **kwargs):

544:         if needles is not None:

545:             self.needles = needles

550:         if len(needles) == 1:

557:                 needles=self.needles)

587:         self.needles = []

595:             self.needles.append(tmp.obj_vm.read(0, tmp.obj_size))

597:         # The common string between all the needles.

599:             ("MultiStringFinderCheck", dict(needles=self.needles)),

22: needle = [0x02, 0x0a, 0x80]  # LJMP 0xA80

25: while i < len(data) - len(needle) + 1 and i < 0xa00:

26:   if all([(a & b) == b for a, b in zip(data[i:i+len(needle)], needle)]):

37: INSERT_NEEDLE = 'If this roll has caused a breakage'

71:     insert_index = old_commit_msg.rfind(INSERT_NEEDLE)

73:         logging.exception('"%s" not found in commit message.' % INSERT_NEEDLE)

2852:     def search_vmas_for_needle(self, search_string=None, pointers=None,

3053:     def search_chunks_for_needle(self, search_string=None, pointers=None,

2307:             for hit in self.search_vmas_for_needle(pointers=[top_chunk.v()]):

2787:             for hit in self.search_vmas_for_needle(pointers=mmap_pointers):

2789:                 found_pointers.add(hit['needle'])

2854:         """Searches all vmas or only the given ones for the given needle(s).

2868:                                                 dict(needle=search_string))])

2901:                     temp['needle'] = pointer

2904:                     temp['needle'] = search_string

3055:         """Searches all chunks for the given needle(s) and returns the ones

3070:             hits = self.search_vmas_for_needle(pointers=pointers,

3074:             hits = self.search_vmas_for_needle(search_string=search_string,

3085:         #   { needle (string or pointer): { offsets: {offsets} }, needle2: ...}

3099:                         result[chunk] = {hit['needle']: {hit['hit']}}

3102:                         if hit['needle'] not in list(result[chunk].keys()):

3103:                             result[chunk][hit['needle']] = {hit['hit']}

3106:                             result[chunk][hit['needle']].add(hit['hit'])

3657:                 hits = self.search_vmas_for_needle(

3661:                 hits = self.search_vmas_for_needle(

4228:                         hits = self.search_chunks_for_needle(

4233:                         temp_hits = self.search_chunks_for_needle(

4264:                                 temp_hit['needle'] = ','.join(rule_strings)

4267:                         temp_hits = self.search_chunks_for_needle(

4308:                             temp_hits = self.search_chunks_for_needle(

4342:                             "We didn't find anything for the given needle(s).")

4350:                         for needle, data in needles.items():

4351:                             if isinstance(needle, malloc_chunk):

4355:                                     "0x{:X}:\n".format(needle.v()))

4371:                                     "The following needle at the given "

4373:                                 renderer.write("Needle     Offset(s)\n")

4378:                                         (hex(needle) if isinstance(needle, int)

4379:                                          else repr(needle)) + ": "

4386:                                         (hex(needle) if isinstance(needle, int)

4387:                                          else repr(needle)) + ": The needle "

4237:                         for chunk, needles in temp_hits.items():

4239:                                 hits[chunk].update(needles)

4242:                                 hits[chunk] = needles

4271:                         for chunk, needles in temp_hits.items():

4273:                                 hits[chunk].update(needles)

4276:                                 hits[chunk] = needles

4345:                     for chunk, needles in hits.items():

150: _BAD_CRYPTO_NEEDLE = 'PKCS12 format is not supported by the PyCrypto library'

627:             if _BAD_CRYPTO_NEEDLE in e.message:

110: _ACCEPT_LICENSE_NEEDLE = 'Do you accept the license'

133: _GRADLEW_INSTALL_SUCCESS_NEEDLE = 'BUILD SUCCESSFUL'

145: _TEST_FAILURE_NEEDLE = 'FAILURES!!!\r'

779:         return _GRADLEW_INSTALL_SUCCESS_NEEDLE not in result

782:         return _TEST_FAILURE_NEEDLE in result

1111:             if _ACCEPT_LICENSE_NEEDLE in line and not process.poll():

400: def test_no_needless_overwrite(cli, tmpdir, datafiles):

435:     # Now (needlessly) track again

1473:     def array_contains(self, needle) -> 'Expression':

1481:         return _binary_op("arrayContains")(self, needle)

1490:     def array_remove(self, needle) -> 'Expression':

1495:         return _binary_op("arrayRemove")(self, needle)

1473:       needle = platform_utils.realpath(self.gitdir)

1486:         if fullpath == needle:

5237:   def FindLineWith(lines, needle):

5238:     """Returns the line number (i.e. index + 1) in `lines` containing `needle`.

5240:     If 0 or >1 lines contain `needle`, -1 is returned.

5246:         if needle in line]

32:   def FindLines(haystack, needle):

34:     |needle|."""

35:     return [ hay for hay in haystack if needle in hay ]

149:     def parse_statements(self, end_tokens, drop_needle=False):

156:         the call is the matched end token.  If this is not wanted `drop_needle`

172:         if drop_needle:

185:                                      drop_needle=True)

203:             else_ = self.parse_statements(('name:endfor',), drop_needle=True)

223:                                                      drop_needle=True)

243:                                           drop_needle=True)

252:                                             drop_needle=True)

268:         node.body = self.parse_statements(('name:endblock',), drop_needle=True)

369:         node.body = self.parse_statements(('name:endcall',), drop_needle=True)

376:                                           drop_needle=True)

384:                                           drop_needle=True)

681:             needle = app.bookmark.Bookmark(beginRow, beginRow, {})

682:             beginIndex = bisect.bisect_left(bookmarkList, needle)

685:             needle.range = (endRow, endRow)

686:             endIndex = bisect.bisect_left(bookmarkList, needle)

457:   def match_prefix_ignore_case_past_end(needle, haystack, offset):

459:     chars_to_scan = min(len(needle), chars_left)

461:       if needle[i] != ascii_to_lower(haystack[i + offset]):

1080:     needle = STR("AACT")

1082:         seq_count(needle)

660: def check_no_extack(res, needle):

661:     fail((res[1] + res[2]).count(needle) or (res[1] + res[2]).count("Warning:"),

662:          "Found '%s' in command output, leaky extack?" % (needle))

680: def test_spurios_extack(sim, obj, skip_hw, needle):

683:     check_no_extack(res, needle)

686:     check_no_extack(res, needle)

689:     check_no_extack(res, needle)

223:     def __init__(self, _root_lexer, _language_lexer, _needle=Other, **options):

226:         self.needle = _needle

234:             if t is self.needle:

276:         needle = app.bookmark.Bookmark(lowerRow + 1, lowerRow + 1, {})

277:         index = bisect.bisect_left(self.bookmarks, needle)

293:         needle = app.bookmark.Bookmark(upperRow, upperRow, {})

294:         index = bisect.bisect_left(self.bookmarks, needle)

308:         needle = app.bookmark.Bookmark(upperRow, lowerRow, {})

310:         begin = bisect.bisect_left(rangeList, needle)

311:         if begin and needle.begin <= rangeList[begin - 1].end:

317:         offset = needle.end

240:         super(PoolTagCheck, self).__init__(needle=tag, **kwargs)

105:                 needles=self.plugin_args.process_name,

267:         super(MultiPoolTagCheck, self).__init__(needles=tags, **kwargs)

641:         needle_lookup = {}

661:                 needle_lookup.setdefault(keyword, []).append(method)

687:             for method in needle_lookup[hit]:

268:                 address_space=test_as, needles=[

640:         needles = []

660:                 needles.append(keyword)

680:             address_space=address_space, needles=needles,

394:   def match_prefix_ignore_case_past_end(needle, haystack, offset):

396:     chars_to_scan = min(len(needle), chars_left)

398:       if needle[i] != ascii_to_lower(haystack[i + offset]):

307:     """Returns the position of 'needle' in 'string', or -1 if not found."""

311:     def __call__(self, string, needle):

312:         return string.find(needle)

527:     def assert_contains(self, needle, haystack):

528:         if haystack.find(needle) == -1:

530:                 'Expected to find %s, found:\n%s', (needle, haystack))

785:         for needle in needles:

786:             assert isinstance(needle, bytes)

787:             yield needle.decode('utf-8'), replacement.decode('utf-8')

793:     longest_needle = ""

795:     for needle, replacement in iter_instead_of(config, push):

796:         if not orig_url.startswith(needle):

798:         if len(longest_needle) < len(needle):

799:             longest_needle = needle

800:             updated_url = replacement + orig_url[len(needle):]

777:             needles = list(config.get_multivar(section, "insteadOf"))

779:             needles = []

782:                 needles += list(config.get_multivar(section, "pushInsteadOf"))

778:     needle = solve(expr.element, vars).value

779:     if repeated.isrepeating(needle):

782:             message=("More than one value not allowed in the needle. "

783:                      "Got %d values.") % counted.count(needle))

796:         return Result(needle in haystack, ())

802:             if straw == needle:

811:         return Result(needle in straw, None)

28: def IsSubListOf(needle, hay):

29:     """Returns whether there is a slice of |hay| equal to |needle|."""

31:         if line == needle[0]:

32:             if needle == hay[i:i + len(needle)]:

141:     def parse_statements(self, end_tokens, drop_needle=False):

148:         the call is the matched end token.  If this is not wanted `drop_needle`

164:         if drop_needle:

191:             else_ = self.parse_statements(('name:endfor',), drop_needle=True)

210:                                                    drop_needle=True)

229:         node.body = self.parse_statements(('name:endblock',), drop_needle=True)

329:         node.body = self.parse_statements(('name:endcall',), drop_needle=True)

336:                                           drop_needle=True)

344:                                           drop_needle=True)

415:                                          drop_needle=True))

429:                                             drop_needle=True)

32:   def FindLines(haystack, needle):

34:     |needle|."""

35:     return [ hay for hay in haystack if needle in hay ]

141:     def parse_statements(self, end_tokens, drop_needle=False):

148:         the call is the matched end token.  If this is not wanted `drop_needle`

164:         if drop_needle:

191:             else_ = self.parse_statements(('name:endfor',), drop_needle=True)

210:                                                    drop_needle=True)

229:         node.body = self.parse_statements(('name:endblock',), drop_needle=True)

329:         node.body = self.parse_statements(('name:endcall',), drop_needle=True)

336:                                           drop_needle=True)

344:                                           drop_needle=True)

276: # Given 'haystack', see if any prefix of 'needle' is at its end.  This

291: def find_prefix_at_end (haystack, needle):

292:     l = len(needle) - 1

293:     while l and not haystack.endswith(needle[:l]):

162:             needle = tuple((self._normalize_token(t)

164:             result = self._table.get(needle)

166:                 return result, needle

633:   for needle in needles:

635:       haystack.remove(needle)

632: def RemoveItemsFromList(haystack, needles):

415:                                          drop_needle=True))

429:                                             drop_needle=True)

195:         self, end_tokens: t.Tuple[str, ...], drop_needle: bool = False

203:         the call is the matched end token.  If this is not wanted `drop_needle`

219:         if drop_needle:

231:         body = self.parse_statements(("name:endset",), drop_needle=True)

250:             else_ = self.parse_statements(("name:endfor",), drop_needle=True)

267:                 result.else_ = self.parse_statements(("name:endif",), drop_needle=True)

285:         node.body = self.parse_statements(("name:endwith",), drop_needle=True)

291:         node.body = self.parse_statements(("name:endautoescape",), drop_needle=True)

309:         node.body = self.parse_statements(("name:endblock",), drop_needle=True)

430:         node.body = self.parse_statements(("name:endcall",), drop_needle=True)

436:         node.body = self.parse_statements(("name:endfilter",), drop_needle=True)

443:         node.body = self.parse_statements(("name:endmacro",), drop_needle=True)

450:       needle = '%s^^^^{commit}' % revision

452:       needle = '%s^{commit}' % revision

456:       self.RunGit(['cat-file', '-e', needle])

163:   def _is_sub_list(needle, haystack):

166:     """True iff `needle` is a sub-list of `haystack` (i.e. a contiguous slice

167:     of `haystack` exactly matches `needle`"""

168:     needle_len = len(needle)

170:     for i in range(0, haystack_len - needle_len + 1):

171:       if haystack[i:i + needle_len] == needle:

141:     def parse_statements(self, end_tokens, drop_needle=False):

148:         the call is the matched end token.  If this is not wanted `drop_needle`

164:         if drop_needle:

191:             else_ = self.parse_statements(('name:endfor',), drop_needle=True)

210:                                                    drop_needle=True)

229:         node.body = self.parse_statements(('name:endblock',), drop_needle=True)

329:         node.body = self.parse_statements(('name:endcall',), drop_needle=True)

336:                                           drop_needle=True)

344:                                           drop_needle=True)

156:     def parse_statements(self, end_tokens, drop_needle=False):

163:         the call is the matched end token.  If this is not wanted `drop_needle`

179:         if drop_needle:

191:         body = self.parse_statements(("name:endset",), drop_needle=True)

210:             else_ = self.parse_statements(("name:endfor",), drop_needle=True)

227:                 result.else_ = self.parse_statements(("name:endif",), drop_needle=True)

245:         node.body = self.parse_statements(("name:endwith",), drop_needle=True)

251:         node.body = self.parse_statements(("name:endautoescape",), drop_needle=True)

268:         node.body = self.parse_statements(("name:endblock",), drop_needle=True)

375:         node.body = self.parse_statements(("name:endcall",), drop_needle=True)

381:         node.body = self.parse_statements(("name:endfilter",), drop_needle=True)

388:         node.body = self.parse_statements(("name:endmacro",), drop_needle=True)

140:     def parse_statements(self, end_tokens, drop_needle=False):

147:         the call is the matched end token.  If this is not wanted `drop_needle`

163:         if drop_needle:

175:                                      drop_needle=True)

193:             else_ = self.parse_statements(('name:endfor',), drop_needle=True)

212:                                                    drop_needle=True)

231:         node.body = self.parse_statements(('name:endblock',), drop_needle=True)

333:         node.body = self.parse_statements(('name:endcall',), drop_needle=True)

340:                                           drop_needle=True)

348:                                           drop_needle=True)

160:     def parse_statements(self, end_tokens, drop_needle=False):

167:         the call is the matched end token.  If this is not wanted `drop_needle`

183:         if drop_needle:

195:         body = self.parse_statements(("name:endset",), drop_needle=True)

214:             else_ = self.parse_statements(("name:endfor",), drop_needle=True)

231:                 result.else_ = self.parse_statements(("name:endif",), drop_needle=True)

249:         node.body = self.parse_statements(("name:endwith",), drop_needle=True)

255:         node.body = self.parse_statements(("name:endautoescape",), drop_needle=True)

273:         node.body = self.parse_statements(("name:endblock",), drop_needle=True)

380:         node.body = self.parse_statements(("name:endcall",), drop_needle=True)

386:         node.body = self.parse_statements(("name:endfilter",), drop_needle=True)

393:         node.body = self.parse_statements(("name:endmacro",), drop_needle=True)