Runs after the user-entered code in a cell has been executed. It
        detects any new, decoratable objects that haven't been decorated yet and
        then decorates them.
966618
def post_run_cell(self):
        
        #We just want to detect any new, decoratable objects that haven't been
        #decorated yet.
        decorlist = {k: [] for k in self.atypes}
        for atype in self.atypes:
            for n, o in self._get_decoratables(atype):
                self._decorate(atype, n, o)

        #Next, check whether we have an outstanding "loop intercept" that we
        #"wrapped" with respect to acorn by enabling streamlining.
        if self.pre is not None:
            #Re-enable the acorn logging systems so that it gets back to normal.
            from acorn.logging.decoration import set_streamlining
            set_streamlining(False)

            from acorn import msg
            from acorn.logging.database import record
            from time import time

            #Determine the elapsed time for the execution of the entire cell.
            entry = self.pre
            entry["e"] = time() - entry["s"]
            #See if we can match the executed cell's code up with one that we
            #intercepted in the past..
            cellid = self._find_cellid(entry["c"])
            if cellid is None:
                cellid = self.cellid

            #Store the contents of the cell *before* they get overwritten by a
            #diff.
            self.cellids[cellid] = entry["c"]
                        
            record("__main__.{0:d}".format(cellid), entry, diff=True)
            msg.info(entry, 1)

            self.pre = None

        #Finally, check whether any new variables have shown up, or have had
        #their values changed.
        from acorn.logging.database import tracker, active_db, Instance
        varchange = self._var_changes()
        taskdb = active_db()
        for n, o in varchange:
            otrack = tracker(o)
            if isinstance(otrack, Instance):
                taskdb.log_uuid(otrack.uuid)

        global thumb_uuid
        if thumb_uuid is not None:
            self._log_images()
            #Reset the image tracker list so that we don't save these images
            #again next cell execution.
            thumb_uuid = None
            
        self.cellid = None
259823
void cell(Cell cell) {
        int left = cell.getLeft();
        int right = cell.getRight();
        // first see if we've got a cell past the last col
        if (right > realColumnCount) {
            // are we past last col entirely?
            if (left == realColumnCount) {
                // single col?
                if (left + 1 != right) {
                    appendColumnRange(new ColumnRange(cell.elementName(), cell, left + 1, right));
                }
                realColumnCount = right;
                return;
            } else {
                // not past entirely
                appendColumnRange(new ColumnRange(cell.elementName(), cell, realColumnCount, right));                
                realColumnCount = right;
            }
        }
        while (currentColRange != null) {
            int hit = currentColRange.hits(left);
            if (hit == 0) {
                ColumnRange newRange = currentColRange.removeColumn(left);
                if (newRange == null) {
                    // zap a list item
                    if (previousColRange != null) {
                        previousColRange.setNext(currentColRange.getNext());
                    }
                    if (first == currentColRange) {
                        first = currentColRange.getNext();
                    }
                    if (last == currentColRange) {
                        last = previousColRange;
                    }
                    currentColRange = currentColRange.getNext();
                } else {
                    if (last == currentColRange) {
                        last = newRange;
                    }
                    currentColRange = newRange;
                }
                return;
            } else if (hit == -1) {
                return;
            } else if (hit == 1) {
                previousColRange = currentColRange;
                currentColRange = currentColRange.getNext();                                
            }
        }
    }
589863
function(suite) {
      this.currentSuite = suite
      this.evalBody(suite.body)
      suite.ran = true
      hook('beforeSuite', suite), suite.hook('before')
      each(suite.specs, function(spec) {
        hook('beforeSpec', spec)
        suite.hook('before_each')
        JSpec.runSpec(spec)
        hook('afterSpec', spec)
        suite.hook('after_each')
      })
      if (suite.hasSuites()) {
        each(suite.suites, function(suite) {
          JSpec.runSuite(suite)
        })
      }
      hook('afterSuite', suite), suite.hook('after')
      this.stats.suitesFinished++
    }
1248472
def run(self):
        

        self.init_run()
        if self.debug: self.dump("AfterInit: ")
        #print("++++++++++++++++ Time: %f"%self.current_time)
        while self.step():
            #self.dump("Time: %f"%self.current_time)
            #print("++++++++++++++++ Time: %f"%self.current_time)
            pass
310817
function(){
			this.columnsVisibleFun();
			this.resetThVariable();
			this.countRowHeight();
			this.noRowsShowFun();
			this.renderTypeFun();
			this.resetScrollLeft();
			this.hideEditMenu();
			if(typeof this.options.afterCreate == 'function'){
				this.options.afterCreate.call(this);
			}
		}
1198178
public function prev()
    {
        if ($this->position <= $this->startRow) {
            throw new PHPExcel_Exception("Row is already at the beginning of range ({$this->startRow} - {$this->endRow})");
        }

        do {
            --$this->position;
        } while (($this->onlyExistingCells) &&
            (!$this->subject->cellExistsByColumnAndRow($this->columnIndex, $this->position)) &&
            ($this->position >= $this->startRow));
    }
727290
def run_cell(self, cell):
        """"""
        logging.info('Running cell:\n%s\n', cell.input)
        self.kc.execute(cell.input)
        reply = self.kc.get_shell_msg()
        status = reply['content']['status']
        traceback_text = ''
        if status == 'error':
            traceback_text = 'Cell raised uncaught exception: \n' + \
                '\n'.join(reply['content']['traceback'])
            logging.info(traceback_text)
        else:
            logging.info('Cell returned')

        outs = list()
        while True:
            try:
                msg = self.kc.get_iopub_msg(timeout=1)
                if msg['msg_type'] == 'status':
                    if msg['content']['execution_state'] == 'idle':
                        break
            except Empty:
                # execution state should return to idle
                # before the queue becomes empty,
                # if it doesn't, something bad has happened
                raise

            content = msg['content']
            msg_type = msg['msg_type']

            # IPython 3.0.0-dev writes pyerr/pyout in the notebook format
            # but uses error/execute_result in the message spec. This does the
            # translation needed for tests to pass with IPython 3.0.0-dev
            notebook3_format_conversions = {
                'error': 'pyerr',
                'execute_result': 'pyout'
            }
            msg_type = notebook3_format_conversions.get(msg_type, msg_type)

            out = NotebookNode(output_type=msg_type)

            if 'execution_count' in content:
                cell['prompt_number'] = content['execution_count']
                out.prompt_number = content['execution_count']

            if msg_type in ('status', 'pyin', 'execute_input'):
                continue
            elif msg_type == 'stream':
                out.stream = content['name']
                # in msgspec 5, this is name, text
                # in msgspec 4, this is name, data
                if 'text' in content:
                    out.text = content['text']
                else:
                    out.text = content['data']
            elif msg_type in ('display_data', 'pyout'):
                for mime, data in content['data'].items():
                    try:
                        attr = self.MIME_MAP[mime]
                    except KeyError:
                        raise NotImplementedError(
                            'unhandled mime type: %s' % mime
                        )

                    # In notebook version <= 3 JSON data is stored as a string
                    # Evaluation of IPython2's JSON gives strings directly
                    # Therefore do not encode for IPython versions prior to 3
                    json_encode = (
                            IPython.version_info[0] >= 3 and
                            mime == "application/json")

                    data_out = data if not json_encode else json.dumps(data)
                    setattr(out, attr, data_out)
            elif msg_type == 'pyerr':
                out.ename = content['ename']
                out.evalue = content['evalue']
                out.traceback = content['traceback']
            elif msg_type == 'clear_output':
                outs = list()
                continue
            else:
                raise NotImplementedError(
                    'unhandled iopub message: %s' % msg_type
                )
            outs.append(out)
        cell['outputs'] = outs

        if status == 'error':
            raise NotebookError(traceback_text)
193185
@Override
    public void onUpdate(Detector.Detections<Barcode> detectionResults, Barcode item) {
        mOverlay.add(mGraphic);
        mGraphic.updateItem(item);
    }
1229597
private void tryRunNext() {
        while (runningSemaphore.tryAcquire()) {
            ExecutionTask execution = queue.poll();
            if (execution != null) {
                // Note: we've removed the execution from the queue so we're committed to running it
                // if we fail to do so for any reason, we need to call the exception handler to fail the execution
                try {
                    execution.submit();
                } catch (Throwable e) {
                    // Any exception here is unexpected
                    runningSemaphore.release();
                    execution.exceptionHandler.handle(e);
                }
            } else {
                runningSemaphore.release();
                break;
            }
        }
    }
159409
public function onCollectionAfter()
    {
        if ($this->progress) {
            $this->progress->finish();
            $this->output->writeln(''); // new line after progress bar
        }
        $this->output->writeln('<info>[END]</info>');
    }
1019877
public void newCell(final int row,
            final int column,
            final String value,
            int mergedColStart) {
        if ( isCellValueEmpty( value ) ) {
            return;
        }
        if ( _isInRuleTable && row == this._ruleStartRow ) {
            return;
        }
        if ( this._isInRuleTable ) {
            processRuleCell( row, column, value, mergedColStart );
        } else {
            processNonRuleCell( row, column, value );
        }
    }
409946
public function onBeforeWrite()
    {
        parent::onBeforeWrite();
        // Check that PlaceableObject with is_main has been set.
        $this->HasMain = false;
        foreach ($this->Regions() as $region) {
            if ($region->IsMain) {
                $this->HasMain = true;
                continue;
            }
            if ($region->hasMethod('Blocks') && $region->Blocks()->exists()) {
                foreach ($region->Blocks() as $block) {
                    if ($block->IsMain) {
                        $this->HasMain = true;
                        continue;
                    }
                }
            }
        }
    }
382376
@Override
    public final void execute() {
        beforeLine = editor.getLine();
        beforeColumn = editor.getColumn();
        doExecute();
        afterLine = editor.getLine();
        afterColumn = editor.getColumn();
    }
466346
def _postrun(cls, span, obj, **kwargs):
        
        span.set_tag("response.status_code", obj.status_code)
        span.set_tag(
            "response.content_lenght", len(getattr(obj, 'content', ""))
        )
336838
@Override
    public void visitAfter(JavaClass obj) {
        isListenerMethod = true;
        for (Code l : listenerCode.keySet()) {
            try {
                super.visitCode(l);
            } catch (StopOpcodeParsingException e) {
                // method already reported
            }
        }
        super.visitAfter(obj);
    }
115096
private void run(IOContext in) {
        IOContext oldInput = input;
        input = in;
        try {
            String incomplete = "";
            while (live) {
                String prompt;
                if (isRunningInteractive()) {
                    prompt = testPrompt
                                    ? incomplete.isEmpty()
                                            ? "\u0005" //ENQ
                                            : "\u0006" //ACK
                                    : incomplete.isEmpty()
                                            ? feedback.getPrompt(currentNameSpace.tidNext())
                                            : feedback.getContinuationPrompt(currentNameSpace.tidNext())
                    ;
                } else {
                    prompt = "";
                }
                String raw;
                try {
                    raw = in.readLine(prompt, incomplete);
                } catch (InputInterruptedException ex) {
                    //input interrupted - clearing current state
                    incomplete = "";
                    continue;
                }
                if (raw == null) {
                    //EOF
                    if (in.interactiveOutput()) {
                        // End after user ctrl-D
                        regenerateOnDeath = false;
                    }
                    break;
                }
                String trimmed = trimEnd(raw);
                if (!trimmed.isEmpty() || !incomplete.isEmpty()) {
                    String line = incomplete + trimmed;

                    // No commands in the middle of unprocessed source
                    if (incomplete.isEmpty() && line.startsWith("/") && !line.startsWith("//") && !line.startsWith("/*")) {
                        processCommand(line.trim());
                    } else {
                        incomplete = processSourceCatchingReset(line);
                    }
                }
            }
        } catch (IOException ex) {
            errormsg("jshell.err.unexpected.exception", ex);
        } finally {
            input = oldInput;
        }
    }
885716
function after (count, callback, context) {
  var runCount = 0
  var rests = []
  context = context || this
  return function () {
    runCount++
    if (runCount <= count) {
      rests.push(arguments[0])
    }
    if (runCount >= count) {
      callback.apply(context, [rests].concat(arraySlice(arguments)))
    }
  }
}