code: def _Inject(self, position, call):
      
      self.EnsureGdbPosition(position[0], position[1], None)
      self.ClearBreakpoints()
      self._AddThreadSpecificBreakpoint(position)
      gdb.parse_and_eval('%s = 1' % GdbCache.PENDINGCALLS_TO_DO)
      gdb.parse_and_eval('%s = 1' % GdbCache.PENDINGBUSY)
      try:
        # We're "armed", risk the blocking call to Continue
        self.Continue(position)
        # Breakpoint was hit!
        if not gdb.selected_thread().is_stopped():
          # This should not happen. Depending on how gdb is being used, the
          # semantics of self.Continue change, so I'd rather leave this check in
          # here, in case we ever *do* end up changing to async mode.
          raise RuntimeError('Gdb is not acting as expected, is it being run in '
                             'async mode?')
      finally:
        gdb.parse_and_eval('%s = 0' % GdbCache.PENDINGBUSY)
      self.Call(position, call)
docs: Injects evaluation of 'call' in a safe location in the inferior.
  
      Due to the way these injected function calls work, gdb must not be killed
      until the call has returned. If that happens, the inferior will be sent
      SIGTRAP upon attempting to return from the dummy frame gdb constructs for
      us, and will most probably crash.
      Args:
        position: array of pid, tid, framedepth specifying the requested position.
        call: Any expression gdb can evaluate. Usually a function call.
      Raises:
        RuntimeError: if gdb is not being run in synchronous exec mode.