Write the PHP equality symbol into the current stream.

@param boolean $spaces Whether to surround the equality symbol with spaces.
@throws StreamAccessException If an error occurs while writing the equality symbol.
430573
public function writeEquals($spaces = true)
    {
        try {
            if ($spaces === true) {
                $this->getStream()->write(' = ');
            } else {
                $this->getStream()->write('=');
            }
        } catch (StreamException $e) {
            $msg = "An error occured while writing the PHP equality symbol (=).";
            throw new StreamAccessException($msg, $this, 0, $e);
        }
    }
1072217
public function stream_write($data)
	{
		$left = substr($this->buffers[$this->name], 0, $this->position);
		$right = substr($this->buffers[$this->name], $this->position + strlen($data));
		$this->buffers[$this->name] = $left . $data . $right;
		$this->position += strlen($data);

		return strlen($data);
	}
743478
function Write($h, $txt, $currentx = 0, $link = '', $directionality = 'ltr', $align = '', $fill = 0)
	{
		if (empty($this->directWrite)) {
			$this->directWrite = new DirectWrite($this, $this->otl, $this->sizeConverter, $this->colorConverter);
		}

		$this->directWrite->Write($h, $txt, $currentx, $link, $directionality, $align, $fill);
	}
1116123
public function peek($characters)
    {
        if ( strlen($this->stream_string) < $this->strpos + $characters ) {
            throw new StreamBufferTooSmallException('Not enough of the stream available.');
        }

        return substr($this->stream_string, $this->strpos, $characters);
    }
90415
public function writePaamayimNekudotayim()
    {
        try {
            $this->writeScopeResolution();
        } catch (StreamAccessException $e) {
            $msg = "An error occured while writing a Paamayim Nekudotayim.";
            throw new StreamAccessException($msg, $this, 0, $e);
        }
    }
1183300
private function setSource(string $newSource): void
    {
        $rawTokens = token_get_all($newSource);
        foreach ($rawTokens as $index => $rawToken) {
            $this->tokenStream[$index] = is_array($rawToken) ? $rawToken : [T_STRING, $rawToken];
        }
    }
84390
private function _checkWhiteSpaceBefore($text) {
		if ($this->_isActive('checkWhiteSpaceBefore')) {

			if (!$this->_config->isException('checkWhiteSpaceBefore', $text)) {

				if (!$this->tokenizer->checkPreviousToken(T_WHITESPACE)) {
					$msg = $this->_getMessage('SPACE_BEFORE_TOKEN', $text);
					$this->_writeError('checkWhiteSpaceBefore', $msg);
				}
			}
		}
	}
352267
private function _checkNoWhiteSpaceAfter($token) {
		if ($this->_isActive('noSpaceAfterToken')) {

			$text = $token->text;

			if (!$this->_config->isException('noSpaceAfterToken', $text)) {

				// The next token is a whitespace
				if ($this->tokenizer->checkNextToken(T_WHITESPACE)) {

					// And the next valid token is on the same line
					$tokenAfter = $this->tokenizer->peekNextValidToken();
					if ($tokenAfter->line === $token->line) {
						$msg = $this->_getMessage('NO_SPACE_AFTER_TOKEN', $text);
						$this->_writeError('noSpaceAfterToken', $msg);
					}
				}
			}
		}
	}
1366559
private function eatWhitespace() {
        // Eat up array until next object is found.
        while($this->getStream() && !$this->arrayEnd) {

            for($i = 0; $i < strlen($this->stream); $i++) {
                if($this->stream{$i} == "{") {
                    // Remove the old part of the object
                    $this->stream = substr($this->stream, $i);
                    $this->openingBrackets = 0;
                    $this->closingBrackets = 0;
                    return true;
                } else if ($this->stream{$i} == "]") {
                    $this->arrayEnd = true;
                    return false;
                }
            }
        }

        $this->arrayEnd = true;
        return false;
    }
188572
protected function _eatWhitespace()
    {
        if (preg_match('/([\t\b\f\n\r ])*/s', $this->source, $matches, PREG_OFFSET_CAPTURE, $this->offset)
            && $matches[0][1] == $this->offset) {
            $this->offset += strlen($matches[0][0]);
        }
    }
204953
public function write($chars)
    {
        if (!isset($this->charReader)) {
            $this->charReader = $this->charReaderFactory->getReaderFor(
                $this->charset);
        }

        $startLength = $this->charReader->getInitialByteSize();

        $fp = fopen('php://memory', 'w+b');
        fwrite($fp, $chars);
        unset($chars);
        fseek($fp, 0, SEEK_SET);

        $buffer = [0];
        $buf_pos = 1;
        $buf_len = 1;
        $has_datas = true;
        do {
            $bytes = [];
            // Buffer Filing
            if ($buf_len - $buf_pos < $startLength) {
                $buf = array_splice($buffer, $buf_pos);
                $new = $this->reloadBuffer($fp, 100);
                if ($new) {
                    $buffer = array_merge($buf, $new);
                    $buf_len = count($buffer);
                    $buf_pos = 0;
                } else {
                    $has_datas = false;
                }
            }
            if ($buf_len - $buf_pos > 0) {
                $size = 0;
                for ($i = 0; $i < $startLength && isset($buffer[$buf_pos]); ++$i) {
                    ++$size;
                    $bytes[] = $buffer[$buf_pos++];
                }
                $need = $this->charReader->validateByteSequence(
                    $bytes, $size);
                if ($need > 0) {
                    if ($buf_len - $buf_pos < $need) {
                        $new = $this->reloadBuffer($fp, $need);

                        if ($new) {
                            $buffer = array_merge($buffer, $new);
                            $buf_len = count($buffer);
                        }
                    }
                    for ($i = 0; $i < $need && isset($buffer[$buf_pos]); ++$i) {
                        $bytes[] = $buffer[$buf_pos++];
                    }
                }
                $this->array[] = $bytes;
                ++$this->array_size;
            }
        } while ($has_datas);

        fclose($fp);
    }
249057
private function _checkNoWhiteSpaceBefore($text) {
		if ($this->_isActive('noSpaceBeforeToken')) {

			if (!$this->_config->isException('noSpaceBeforeToken', $text)) {

				if ($this->tokenizer->checkPreviousToken(T_WHITESPACE)) {

					// To avoid false positives when using a space indentation system,
					// check that we are on the same line as the previous valid token
					$prevValid = $this->tokenizer->peekPrvsValidToken();
					$currentToken = $this->tokenizer->getCurrentToken();
					if ($prevValid->line === $currentToken->line) {
						$msg = $this->_getMessage('NO_SPACE_BEFORE_TOKEN', $text);
						$this->_writeError('noSpaceBeforeToken', $msg);
					}
				}
			}
		}
	}
806224
public function writeDouble(Stream $stream, $value)
    {
        $bytes = pack('d*', $value);

        if ($this->isBigEndian) {
            $bytes = strrev($bytes);
        }

        $this->writeBytes($stream, $bytes, 8);
    }
772265
public function ignoreWhitespace()
    {
        ignoreWhitespace:
        if (! $this->isEnd() && $this->currentAscii()->isWhiteSpace()) {
            $this->next();
            goto ignoreWhitespace;
        }
    }
950253
public function writeArguments(PhpArgumentCollection $arguments)
    {
        try {
            $argsCount = count($arguments);

            for ($i = 0; $i < $argsCount; $i++) {

                $this->writeArgument($arguments[$i]);

                if ($i < $argsCount - 1) {
                    $this->writeComma();
                }
            }
        } catch (Exception $e) {
            $msg = "An error occured while writing a sequence of arguments.";
            throw new StreamAccessException($msg, $this, 0, $e);
        }
    }
1105844
public function writeOpeningParenthesis()
    {
        try {
            $this->getStream()->write('(');
        } catch (StreamException $e) {
            $msg = "An error occured while writing an opening parenthesis (().";
            throw new StreamAccessException($msg, $this, 0, $e);
        }
    }
1039683
private function skipToNextStringOrNamespaceSeparator(\ArrayIterator $tokens)
    {
        while ($tokens->valid() && (T_STRING !== $tokens->current()[0]) && (T_NS_SEPARATOR !== $tokens->current()[0])) {
            $tokens->next();
        }
    }