Reads a single line from standard input.

@return string The single line from standard input
962164
private function readline()
    {
        if ($this->hasReadline) {
            $line = readline($this->prompt);
        } else {
            $this->output->write($this->prompt);
            $line = fgets(STDIN, 1024);
            $line = (!$line && strlen($line) == 0) ? false : rtrim($line);
        }

        return $line;
    }
986327
protected function readLine()
    {
        $buffer = '';

        while ($buffer === '') {
            if (($buffer = fgets($this->getFileHandler())) === false) {
                $this->currentLine = null;

                return;
            }
            $buffer = trim($buffer, "\n\r\0");

            if (!$this->skipEmptyLines) {
                break;
            }
        }

        $this->currentLine = $buffer;
    }
1111966
public function readPhpInt()
    {
        list(, $res) = unpack('N', $this->_rawread(4));
        if ($this->_is64bits) {
            $sres = sprintf("%u", $res);
            return (int)$sres;
        } else {
            return $res;
        }
    }
363715
public function readString()
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }

        $string = '';
        while (($char = @fread($this->fp, 1)) !== "\x00") {
            $string .= $char;
        }

        return $string;
    }
262143
public function readString()
    {
        try {
            $binLength = $this->getStream()->read(2);
            $length = current(unpack('S', $binLength));

            return $this->getStream()->read($length);
        } catch (StreamException $e) {
            $this->handleStreamException($e, BinaryStreamAccessException::STRING);
        }
    }
832556
public function readLine($length = 1024)
    {
        if ($this->ensureContent() === false) {
            return false;
        }

        $line = '';
        while ($this->ensureContent()) {
            $char = $this->readByte();

            if ($char === "\n") {
                break;
            }

            if ($char === "\r") {
                if ($this->getByte() === "\n") {
                    $this->addOffset(1);
                }
                break;
            }

            $line .= $char;

            if (\strlen($line) >= $length) {
                break;
            }
        }

        return $line;
    }
792767
private function get() {

		// Get next input character and advance position in file
		if ($this->inPos < $this->inLength) {
			$c = $this->in[$this->inPos];
			++$this->inPos;
		}
		else {
			return self::EOF;
		}

		// Test for non-problematic characters
		if ($c === "\n" || $c === self::EOF || ord($c) >= self::ORD_space) {
			return $c;
		}

		// else
		// Make linefeeds into newlines
		
		if ($c === "\r") {
			return "\n";
		}

		// else
		// Consider space

		return ' ';
	}
684521
def readline(self):
        """"""
        if self.line_number >= self.total_lines:
            return ''
        line = self.lines[self.line_number]
        self.line_number += 1
        if self.indent_char is None and line[:1] in WHITESPACE:
            self.indent_char = line[0]
        return line
1103088
protected function scanNewline()
    {
        if ('' !== $this->getTrimmedLine()) {
            return null;
        }

        $token = $this->takeToken('Newline', mb_strlen($this->line, 'utf8'));
        $this->consumeLine();

        return $token;
    }
609723
private function readLine(): string
    {
        $buffer = '';
        $size = 0;

        // \r\n is two chars which requires slightly different logic.
        // Check this outside of the while loop to save an if statement for each character.
        if ($this->eol !== "\r\n") {
            while (!$this->stream->eof()) {
                // Using a loose equality here to match on '' and false.
                if (null == ($byte = $this->stream->read(1))) {
                    return $buffer;
                }
                $buffer .= $byte;

                // Break when a new line is found or the max length - 1 is reached
                if ($byte === $this->eol || ++$size === $this->maxLineLength - 1) {
                    break;
                }
            }
        } else {
            $prevByte = null;
            while (!$this->stream->eof()) {
                // Using a loose equality here to match on '' and false.
                if (null == ($byte = $this->stream->read(1))) {
                    return $buffer;
                }
                $buffer .= $byte;

                // Break when a new line is found or the max length - 2 is reached
                if ($prevByte . $byte === $this->eol || ++$size === $this->maxLineLength - 2) {
                    break;
                }

                $prevByte = $byte;
            }
        }

        return $buffer;
    }
322466
public function readLine()
	{
		$output = $this->ssh->_get_channel_packet(SSH2::CHANNEL_EXEC);

		return $output === true ? null : $output;
	}
563944
public static String readlineFromStdIn() throws IOException {
		StringBuilder ret = new StringBuilder();
		int c;
		while ((c = System.in.read()) != '\n' && c != -1) {
			if (c != '\r')
				ret.append((char) c);
		}
		return ret.toString();
	}
585742
public function getLine()
    {
        $data = fgetcsv($this->handle, 0, $this->delimiter, $this->enclosure, $this->escape_char);
        if ($data) {
            $this->line++;
        }

        return $data;
    }
1181422
public function readStringLen()
    {
        $l = $this->readIntLen();
        if ($l === null) {
            return $l;
        }

        return $this->read($l);
    }
727669
protected function readLine()
    {
        if (! $this->valid()) {
            throw new Error('End of stream reached, no data to read');
        }
        $this->currentData = fgetcsv($this->fp, null, $this->delimiter, $this->enclosure);
        // Check if EOF is reached
        if (false === $this->currentData) {
            return false;
        } elseif (array(null) == $this->currentData) {
            /*
             * An empty line in the csv file
             * is returned as an array containing a NULL value.
             */
            if (! $this->ignoreEmptyLines) {
                throw new Error('Empty line found in file');
            }
            return $this->readLine();
        }
        $this->curLine++;

        if ($this->inputEncoding != $this->outputEncoding) {
            $inEnc = $this->inputEncoding;
            $outEnc = $this->outputEncoding;
            array_walk($this->currentData, function (&$str) use ($inEnc, $outEnc) {
                $str = mb_convert_encoding($str, $outEnc, $inEnc);
            });
        }

        return $this->currentData;
    }
729930
protected function read()
    {
        $line = fgets($this->input);
        if ($line === false) {
            throw new PAGIException('Could not read from AGI');
        }
        $line = substr($line, 0, -1);
        $this->logger->debug('Read: ' . $line);
        return $line;
    }
457424
public function readLast()
    {

        $len = strlen($this->data);
        $string = $this->data{strlen($this->data) - 1};
        $this->data = substr($this->data, 0, $len - 1);
        $this->length -= 1;

        return $string;
    }