Process an empty line in a block scalar.
550443
def parse_block_scalar_empty_line(indent_token_class, content_token_class):
        """"""
        def callback(lexer, match, context):
            text = match.group()
            if (context.block_scalar_indent is None or
                    len(text) <= context.block_scalar_indent):
                if text:
                    yield match.start(), indent_token_class, text
            else:
                indentation = text[:context.block_scalar_indent]
                content = text[context.block_scalar_indent:]
                yield match.start(), indent_token_class, indentation
                yield (match.start()+context.block_scalar_indent,
                       content_token_class, content)
            context.pos = match.end()
        return callback
159685
def handle_input(self, code):
        """"""
        if not self.prompt.multiline:
            if not should_indent(code):
                try:
                    return self.comp.parse_block(code)
                except CoconutException:
                    pass
            while True:
                line = self.get_input(more=True)
                if line is None:
                    return None
                elif line:
                    code += "\n" + line
                else:
                    break
        try:
            return self.comp.parse_block(code)
        except CoconutException:
            logger.display_exc()
        return None
46009
def _pyfftw_empty_aligned(shape, dtype, order='C', n=None):
    """"""

    return cp.empty(shape, dtype, order)
679857
def p_parallelblock_empty(self, p):
        ''
        p[0] = ParallelBlock((), lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
824175
void zeroWidthSpace(int indentLevel) throws IOException {
    if (closed) throw new IllegalStateException("closed");

    if (column == 0) return;
    if (this.nextFlush != null) flush(nextFlush);
    this.nextFlush = FlushType.EMPTY;
    this.indentLevel = indentLevel;
  }
796196
function lastNonEmptyLine (linesArray) {
  let idx = linesArray.length - 1

  while (idx >= 0 && !linesArray[idx]) {
    idx--
  }

  return idx
}
994410
def empty_positions(&block)
      positions = []
      each_position do |row, column|
        next if get_cell(row, column)
        yield(row, column) if block_given?
        positions << [row, column]
      end
      positions
    end
238210
def construct_scalar(self, node):
        '''
        
        '''
        if node.tag == 'tag:yaml.org,2002:int':
            if node.value == '0':
                pass
            elif node.value.startswith('0') and not node.value.startswith(('0b', '0x')):
                node.value = node.value.lstrip('0')
                # If value was all zeros, node.value would have been reduced to
                # an empty string. Change it to '0'.
                if node.value == '':
                    node.value = '0'
        return super(SaltYamlSafeLoader, self).construct_scalar(node)
21169
def _isnull(expr):
    

    if isinstance(expr, SequenceExpr):
        return IsNull(_input=expr, _data_type=types.boolean)
    elif isinstance(expr, Scalar):
        return IsNull(_input=expr, _value_type=types.boolean)
350894
def blocks(self, lines):
        """"""
        state = markdown.blockparser.State()
        blocks = []

        # We use three states: start, ``` and '\n'
        state.set('start')

        # index of current block
        currblock = 0

        for line in lines:
            line += '\n'
            if state.isstate('start'):
                if line[:3] == '```':
                    state.set('```')
                else:
                    state.set('\n')
                blocks.append('')
                currblock = len(blocks) - 1
            else:
                marker = line[:3]  # Will capture either '\n' or '```'
                if state.isstate(marker):
                    state.reset()
            blocks[currblock] += line

        return blocks
1154567
def iterateBlocksFrom(block):
        
        count = 0
        while block.isValid() and count < MAX_SEARCH_OFFSET_LINES:
            yield block
            block = block.next()
            count += 1
885643
function (block) {
        es.readArray([
          '<!--',
          '  processed by htmlbuild',
          '-->'
        ].map(function (str) {
          return block.indent + str;
        })).pipe(block);
      }
1185109
def scalar(cls, value):
    """"""
    return lambda i, name: cls(i, name, (value,), lambda a: a[0], None)
105396
def p_block_empty(self, p):
        ''
        p[0] = Block((), lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
20007
def readline(self, timeout = 0.1):
        
        try:
            return self._q.get(block = timeout is not None,
                               timeout = timeout)
        except Empty:
            return None
709930
def blockstart_tolineno(self):
        
        if self.name:
            return self.name.tolineno
        if self.type:
            return self.type.tolineno
        return self.lineno
616105
def p_namedblock_empty(self, p):
        ''
        p[0] = Block((), p[3], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))