Pops the top frame off the frame stack.
9628
def __pop_top_frame(self):
        """"""
        popped = self.__stack.pop()
        if self.__stack:
            self.__stack[-1].process_subframe(popped)
105727
public ZFrame unwrap()
    {
        if (size() == 0) {
            return null;
        }
        ZFrame f = pop();
        ZFrame empty = getFirst();
        if (empty.hasData() && empty.size() == 0) {
            empty = pop();
            empty.destroy();
        }
        return f;
    }
1292085
public void clearStack() {
        if (!isValid()) {
            throw new IllegalStateException("accessing top or bottom frame");
        }
        assert slotList.size() >= numLocals;
        if (slotList.size() > numLocals) {
            slotList.subList(numLocals, slotList.size()).clear();
        }
    }
1300560
def stack_pop(self, key):
        
        task = Task.current_task()
        try:
            context = task._context_stack
        except AttributeError:
            raise KeyError('pop from empty stack') from None
        value = context[key]
        stack_value = value.pop()
        if not value:
            context.pop(key)
        return stack_value
938976
def pop_frame(self):
        
        try:
            offset, return_pos = self._frames.pop()
        except IndexError:
            raise IndexError('no frames to pop')
        self._total_offset -= offset

        self.seek(return_pos)
247669
public Map<String, Iterable<? extends WindupVertexFrame>> pop()
    {
        Map<String, Iterable<? extends WindupVertexFrame>> frame = deque.pop();
        return frame;
    }
363198
function() {
            Kinetic.Node.prototype.moveToTop.call(this);
            var stage = this.getStage();
            if(stage) {
                stage.content.removeChild(this.getCanvas()._canvas);
                stage.content.appendChild(this.getCanvas()._canvas);
            }
        }
526312
def pop(self):
        
        if self.next is None:
            raise SimEmptyCallStackError("Cannot pop a frame from an empty call stack.")
        new_list = self.next.copy({})

        if self.state is not None:
            self.state.register_plugin('callstack', new_list)
            self.state.history.recent_stack_actions.append(CallStackAction(
                hash(new_list), len(new_list), 'pop', ret_site_addr=self.ret_addr
            ))

        return new_list
1318044
public E pop() throws EmptyStackException
   {
     E answer = peek(); // Throws EmptyStackException if there's nothing there
     _elements.get().remove(_elements.get().size()-1);
     return answer;     
   }
798336
function() {
      if (!this.openAsModal_) { return; }
      this.openAsModal_ = false;
      this.dialog_.style.zIndex = '';

      // This won't match the native <dialog> exactly because if the user set top on a centered
      // polyfill dialog, that top gets thrown away when the dialog is closed. Not sure it's
      // possible to polyfill this perfectly.
      if (this.replacedStyleTop_) {
        this.dialog_.style.top = '';
        this.replacedStyleTop_ = false;
      }

      // Clear the backdrop and remove from the manager.
      this.backdrop_.parentNode && this.backdrop_.parentNode.removeChild(this.backdrop_);
      dialogPolyfill.dm.removeDialog(this);
    }
544525
def enclosing_frame(frame=None, level=2):
    """"""
    frame = frame or sys._getframe(level)
    while frame.f_globals.get('__name__') == __name__: frame = frame.f_back
    return frame
1140667
void remove(JInternalFrame internalFrame)
    {
        Component component = frameToComponent.get(internalFrame);
        container.remove(component);
    }
332382
def pop_frame(self):
        
        self.frames.pop(0)
        if len(self.frames) == 0:
            raise Exception("stack is exhausted")
        return self.frames[0]
546599
public void popIn ()
    {
        String front = _pushed.remove(_pushed.size() - 1);
        if (front != null) {
            _imports.add(front);
        }
    }
145398
def endclip(self):
        """"""
        self.__clip_box = self.__clip_stack[-1]
        del self.__clip_stack[-1]
        self.grestore()
782116
def get_stack_frame(N=0, strict=True):
    
    frame_cur = inspect.currentframe()
    for _ix in range(N + 1):
        # always skip the frame of this function
        frame_next = frame_cur.f_back
        if frame_next is None:
            if strict:
                raise AssertionError('Frame level %r is root' % _ix)
            else:
                break
        frame_cur = frame_next
    return frame_cur
440404
def root_frame(self, trim_stem=True):
        ''' 
        
        '''
        root_frame = None

        frame_stack = []

        for frame_tuple in self.frame_records:
            identifier_stack = frame_tuple[0]
            time = frame_tuple[1]

            # now we must create a stack of frame objects and assign this time to the leaf
            for stack_depth, frame_identifier in enumerate(identifier_stack):
                if stack_depth < len(frame_stack):
                    if frame_identifier != frame_stack[stack_depth].identifier:
                        # trim any frames after and including this one
                        del frame_stack[stack_depth:]

                if stack_depth >= len(frame_stack):
                    frame = Frame(frame_identifier)
                    frame_stack.append(frame)
                    
                    if stack_depth == 0:
                        # There should only be one root frame, as far as I know
                        assert root_frame is None, ASSERTION_MESSAGE
                        root_frame = frame
                    else:
                        parent = frame_stack[stack_depth-1]
                        parent.add_child(frame)

            # trim any extra frames
            del frame_stack[stack_depth+1:]  # pylint: disable=W0631

            # assign the time to the final frame
            frame_stack[-1].add_child(SelfTimeFrame(self_time=time))
        
        if root_frame is None:
            return None
        
        if trim_stem:
            root_frame = self._trim_stem(root_frame)
        
        return root_frame