php/src/Google/Protobuf/Internal/GPBWire.php - third_party/protobuf - Git at Google

 <?php

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 namespace Google\Protobuf\Internal;

 class GPBWire
 {

     const TAG_TYPE_BITS = 3;

     const WIRETYPE_VARINT  = 0;
     const WIRETYPE_FIXED64 = 1;
     const WIRETYPE_LENGTH_DELIMITED = 2;
     const WIRETYPE_START_GROUP = 3;
     const WIRETYPE_END_GROUP = 4;
     const WIRETYPE_FIXED32 = 5;

     const UNKNOWN = 0;
     const NORMAL_FORMAT = 1;
     const PACKED_FORMAT = 2;

     public static function getTagFieldNumber($tag)
     {
         return ($tag >> self::TAG_TYPE_BITS) &
             (1 << ((PHP_INT_SIZE * 8) - self::TAG_TYPE_BITS)) - 1;
     }

     public static function getTagWireType($tag)
     {
         return $tag & 0x7;
     }

     public static function getWireType($type)
     {
         switch ($type) {
             case GPBType::FLOAT:
             case GPBType::FIXED32:
             case GPBType::SFIXED32:
                 return self::WIRETYPE_FIXED32;
             case GPBType::DOUBLE:
             case GPBType::FIXED64:
             case GPBType::SFIXED64:
                 return self::WIRETYPE_FIXED64;
             case GPBType::UINT32:
             case GPBType::UINT64:
             case GPBType::INT32:
             case GPBType::INT64:
             case GPBType::SINT32:
             case GPBType::SINT64:
             case GPBType::ENUM:
             case GPBType::BOOL:
                 return self::WIRETYPE_VARINT;
             case GPBType::STRING:
             case GPBType::BYTES:
             case GPBType::MESSAGE:
                 return self::WIRETYPE_LENGTH_DELIMITED;
             case GPBType::GROUP:
                 user_error("Unsupported type.");
                 return 0;
             default:
                 user_error("Unsupported type.");
                 return 0;
         }
     }

   // ZigZag Transform:  Encodes signed integers so that they can be effectively
   // used with varint encoding.
   //
   // varint operates on unsigned integers, encoding smaller numbers into fewer
   // bytes.  If you try to use it on a signed integer, it will treat this
   // number as a very large unsigned integer, which means that even small
   // signed numbers like -1 will take the maximum number of bytes (10) to
   // encode.  zigZagEncode() maps signed integers to unsigned in such a way
   // that those with a small absolute value will have smaller encoded values,
   // making them appropriate for encoding using varint.
   //
   // int32 ->     uint32
   // -------------------------
   //           0 ->          0
   //          -1 ->          1
   //           1 ->          2
   //          -2 ->          3
   //         ... ->        ...
   //  2147483647 -> 4294967294
   // -2147483648 -> 4294967295
   //
   //        >> encode >>
   //        << decode <<
   public static function zigZagEncode32($int32)
   {
       if (PHP_INT_SIZE == 8) {
           $trim_int32 = $int32 & 0xFFFFFFFF;
           return (($trim_int32 << 1) ^ ($int32 << 32 >> 63)) & 0xFFFFFFFF;
       } else {
           return ($int32 << 1) ^ ($int32 >> 31);
       }
   }

     public static function zigZagDecode32($uint32)
     {
         // Fill high 32 bits.
         if (PHP_INT_SIZE === 8) {
             $uint32 |= ($uint32 & 0xFFFFFFFF);
         }

         $int32 = (($uint32 >> 1) & 0x7FFFFFFF) ^ (-($uint32 & 1));

         return $int32;
     }

     public static function zigZagEncode64($int64)
     {
         if (PHP_INT_SIZE == 4) {
             if (bccomp($int64, 0) >= 0) {
                 return bcmul($int64, 2);
             } else {
                 return bcsub(bcmul(bcsub(0, $int64), 2), 1);
             }
         } else {
             return ($int64 << 1) ^ ($int64 >> 63);
         }
     }

     public static function zigZagDecode64($uint64)
     {
         if (PHP_INT_SIZE == 4) {
             if (bcmod($uint64, 2) == 0) {
                 return bcdiv($uint64, 2, 0);
             } else {
                 return bcsub(0, bcdiv(bcadd($uint64, 1), 2, 0));
             }
         } else {
             return (($uint64 >> 1) & 0x7FFFFFFFFFFFFFFF) ^ (-($uint64 & 1));
         }
     }

     public static function readInt32(&$input, &$value)
     {
         return $input->readVarint32($value);
     }

     public static function readInt64(&$input, &$value)
     {
         $success = $input->readVarint64($value);
         if (PHP_INT_SIZE == 4 && bccomp($value, "9223372036854775807") > 0) {
             $value = bcsub($value, "18446744073709551616");
         }
         return $success;
     }

     public static function readUint32(&$input, &$value)
     {
         return self::readInt32($input, $value);
     }

     public static function readUint64(&$input, &$value)
     {
         return self::readInt64($input, $value);
     }

     public static function readSint32(&$input, &$value)
     {
         if (!$input->readVarint32($value)) {
             return false;
         }
         $value = GPBWire::zigZagDecode32($value);
         return true;
     }

     public static function readSint64(&$input, &$value)
     {
         if (!$input->readVarint64($value)) {
             return false;
         }
         $value = GPBWire::zigZagDecode64($value);
         return true;
     }

     public static function readFixed32(&$input, &$value)
     {
         return $input->readLittleEndian32($value);
     }

     public static function readFixed64(&$input, &$value)
     {
         return $input->readLittleEndian64($value);
     }

     public static function readSfixed32(&$input, &$value)
     {
         if (!self::readFixed32($input, $value)) {
             return false;
         }
         if (PHP_INT_SIZE === 8) {
             $value |= (-($value >> 31) << 32);
         }
         return true;
     }

     public static function readSfixed64(&$input, &$value)
     {
         $success = $input->readLittleEndian64($value);
         if (PHP_INT_SIZE == 4 && bccomp($value, "9223372036854775807") > 0) {
             $value = bcsub($value, "18446744073709551616");
         }
         return $success;
     }

     public static function readFloat(&$input, &$value)
     {
         $data = null;
         if (!$input->readRaw(4, $data)) {
             return false;
         }
         $value = unpack('f', $data)[1];
         return true;
     }

     public static function readDouble(&$input, &$value)
     {
         $data = null;
         if (!$input->readRaw(8, $data)) {
             return false;
         }
         $value = unpack('d', $data)[1];
         return true;
     }

     public static function readBool(&$input, &$value)
     {
         if (!$input->readVarint64($value)) {
             return false;
         }
         if ($value == 0) {
             $value = false;
         } else {
             $value = true;
         }
         return true;
     }

     public static function readString(&$input, &$value)
     {
         $length = 0;
         return $input->readVarintSizeAsInt($length) && $input->readRaw($length, $value);
     }

     public static function readMessage(&$input, &$message)
     {
         $length = 0;
         if (!$input->readVarintSizeAsInt($length)) {
             return false;
         }
         $old_limit = 0;
         $recursion_limit = 0;
         $input->incrementRecursionDepthAndPushLimit(
             $length,
             $old_limit,
             $recursion_limit);
         if ($recursion_limit < 0 || !$message->parseFromStream($input)) {
             return false;
         }
         return $input->decrementRecursionDepthAndPopLimit($old_limit);
     }

     public static function writeTag(&$output, $tag)
     {
         return $output->writeTag($tag);
     }

     public static function writeInt32(&$output, $value)
     {
         return $output->writeVarint32($value, false);
     }

     public static function writeInt64(&$output, $value)
     {
         return $output->writeVarint64($value);
     }

     public static function writeUint32(&$output, $value)
     {
         return $output->writeVarint32($value, true);
     }

     public static function writeUint64(&$output, $value)
     {
         return $output->writeVarint64($value);
     }

     public static function writeSint32(&$output, $value)
     {
         $value = GPBWire::zigZagEncode32($value);
         return $output->writeVarint32($value, true);
     }

     public static function writeSint64(&$output, $value)
     {
         $value = GPBWire::zigZagEncode64($value);
         return $output->writeVarint64($value);
     }

     public static function writeFixed32(&$output, $value)
     {
         return $output->writeLittleEndian32($value);
     }

     public static function writeFixed64(&$output, $value)
     {
         return $output->writeLittleEndian64($value);
     }

     public static function writeSfixed32(&$output, $value)
     {
         return $output->writeLittleEndian32($value);
     }

     public static function writeSfixed64(&$output, $value)
     {
         return $output->writeLittleEndian64($value);
     }

     public static function writeBool(&$output, $value)
     {
         if ($value) {
             return $output->writeVarint32(1, true);
         } else {
             return $output->writeVarint32(0, true);
         }
     }

     public static function writeFloat(&$output, $value)
     {
         $data = pack("f", $value);
         return $output->writeRaw($data, 4);
     }

     public static function writeDouble(&$output, $value)
     {
         $data = pack("d", $value);
         return $output->writeRaw($data, 8);
     }

     public static function writeString(&$output, $value)
     {
         return self::writeBytes($output, $value);
     }

     public static function writeBytes(&$output, $value)
     {
         $size = strlen($value);
         if (!$output->writeVarint32($size, true)) {
             return false;
         }
         return $output->writeRaw($value, $size);
     }

     public static function writeMessage(&$output, $value)
     {
         $size = $value->byteSize();
         if (!$output->writeVarint32($size, true)) {
             return false;
         }
         return $value->serializeToStream($output);
     }

     public static function makeTag($number, $type)
     {
         return ($number << 3) | self::getWireType($type);
     }

     public static function tagSize($field)
     {
         $tag = self::makeTag($field->getNumber(), $field->getType());
         return self::varint32Size($tag);
     }

     public static function varint32Size($value, $sign_extended = false)
     {
         if ($value < 0) {
             if ($sign_extended) {
                 return 10;
             } else {
                 return 5;
             }
         }
         if ($value < (1 <<  7)) {
             return 1;
         }
         if ($value < (1 << 14)) {
             return 2;
         }
         if ($value < (1 << 21)) {
             return 3;
         }
         if ($value < (1 << 28)) {
             return 4;
         }
         return 5;
     }

     public static function sint32Size($value)
     {
         $value = self::zigZagEncode32($value);
         return self::varint32Size($value);
     }

     public static function sint64Size($value)
     {
         $value = self::zigZagEncode64($value);
         return self::varint64Size($value);
     }

     public static function varint64Size($value)
     {
         if (PHP_INT_SIZE == 4) {
             if (bccomp($value, 0) < 0 ||
                 bccomp($value, "9223372036854775807") > 0) {
                 return 10;
             }
             if (bccomp($value, 1 << 7) < 0) {
                 return 1;
             }
             if (bccomp($value, 1 << 14) < 0) {
                 return 2;
             }
             if (bccomp($value, 1 << 21) < 0) {
                 return 3;
             }
             if (bccomp($value, 1 << 28) < 0) {
                 return 4;
             }
             if (bccomp($value, '34359738368') < 0) {
                 return 5;
             }
             if (bccomp($value, '4398046511104') < 0) {
                 return 6;
             }
             if (bccomp($value, '562949953421312') < 0) {
                 return 7;
             }
             if (bccomp($value, '72057594037927936') < 0) {
                 return 8;
             }
             return 9;
         } else {
             if ($value < 0) {
                 return 10;
             }
             if ($value < (1 <<  7)) {
                 return 1;
             }
             if ($value < (1 << 14)) {
                 return 2;
             }
             if ($value < (1 << 21)) {
                 return 3;
             }
             if ($value < (1 << 28)) {
                 return 4;
             }
             if ($value < (1 << 35)) {
                 return 5;
             }
             if ($value < (1 << 42)) {
                 return 6;
             }
             if ($value < (1 << 49)) {
                 return 7;
             }
             if ($value < (1 << 56)) {
                 return 8;
             }
             return 9;
         }
     }

     public static function serializeFieldToStream(
         $value,
         $field,
         $need_tag,
         &$output)
     {
         if ($need_tag) {
             if (!GPBWire::writeTag(
                 $output,
                 self::makeTag(
                     $field->getNumber(),
                     $field->getType()))) {
                 return false;
             }
         }
         switch ($field->getType()) {
             case GPBType::DOUBLE:
                 if (!GPBWire::writeDouble($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::FLOAT:
                 if (!GPBWire::writeFloat($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::INT64:
                 if (!GPBWire::writeInt64($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::UINT64:
                 if (!GPBWire::writeUint64($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::INT32:
                 if (!GPBWire::writeInt32($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::FIXED32:
                 if (!GPBWire::writeFixed32($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::FIXED64:
                 if (!GPBWire::writeFixed64($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::BOOL:
                 if (!GPBWire::writeBool($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::STRING:
                 if (!GPBWire::writeString($output, $value)) {
                     return false;
                 }
                 break;
             //    case GPBType::GROUP:
             //      echo "GROUP\xA";
             //      trigger_error("Not implemented.", E_ERROR);
             //      break;
             case GPBType::MESSAGE:
                 if (!GPBWire::writeMessage($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::BYTES:
                 if (!GPBWire::writeBytes($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::UINT32:
                 if (PHP_INT_SIZE === 8 && $value < 0) {
                     $value += 4294967296;
                 }
                 if (!GPBWire::writeUint32($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::ENUM:
                 if (!GPBWire::writeInt32($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::SFIXED32:
                 if (!GPBWire::writeSfixed32($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::SFIXED64:
                 if (!GPBWire::writeSfixed64($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::SINT32:
                 if (!GPBWire::writeSint32($output, $value)) {
                     return false;
                 }
                 break;
             case GPBType::SINT64:
                 if (!GPBWire::writeSint64($output, $value)) {
                     return false;
                 }
                 break;
             default:
                 user_error("Unsupported type.");
                 return false;
         }

         return true;
     }
 }
	<?php

	// Protocol Buffers - Google's data interchange format
	// Copyright 2008 Google Inc. All rights reserved.
	// https://developers.google.com/protocol-buffers/
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	namespace Google\Protobuf\Internal;

	class GPBWire
	{

	const TAG_TYPE_BITS = 3;

	const WIRETYPE_VARINT = 0;
	const WIRETYPE_FIXED64 = 1;
	const WIRETYPE_LENGTH_DELIMITED = 2;
	const WIRETYPE_START_GROUP = 3;
	const WIRETYPE_END_GROUP = 4;
	const WIRETYPE_FIXED32 = 5;

	const UNKNOWN = 0;
	const NORMAL_FORMAT = 1;
	const PACKED_FORMAT = 2;

	public static function getTagFieldNumber($tag)
	{
	return ($tag >> self::TAG_TYPE_BITS) &
	(1 << ((PHP_INT_SIZE * 8) - self::TAG_TYPE_BITS)) - 1;
	}

	public static function getTagWireType($tag)
	{
	return $tag & 0x7;
	}

	public static function getWireType($type)
	{
	switch ($type) {
	case GPBType::FLOAT:
	case GPBType::FIXED32:
	case GPBType::SFIXED32:
	return self::WIRETYPE_FIXED32;
	case GPBType::DOUBLE:
	case GPBType::FIXED64:
	case GPBType::SFIXED64:
	return self::WIRETYPE_FIXED64;
	case GPBType::UINT32:
	case GPBType::UINT64:
	case GPBType::INT32:
	case GPBType::INT64:
	case GPBType::SINT32:
	case GPBType::SINT64:
	case GPBType::ENUM:
	case GPBType::BOOL:
	return self::WIRETYPE_VARINT;
	case GPBType::STRING:
	case GPBType::BYTES:
	case GPBType::MESSAGE:
	return self::WIRETYPE_LENGTH_DELIMITED;
	case GPBType::GROUP:
	user_error("Unsupported type.");
	return 0;
	default:
	user_error("Unsupported type.");
	return 0;
	}
	}

	// ZigZag Transform: Encodes signed integers so that they can be effectively
	// used with varint encoding.
	//
	// varint operates on unsigned integers, encoding smaller numbers into fewer
	// bytes. If you try to use it on a signed integer, it will treat this
	// number as a very large unsigned integer, which means that even small
	// signed numbers like -1 will take the maximum number of bytes (10) to
	// encode. zigZagEncode() maps signed integers to unsigned in such a way
	// that those with a small absolute value will have smaller encoded values,
	// making them appropriate for encoding using varint.
	//
	// int32 -> uint32
	// -------------------------
	// 0 -> 0
	// -1 -> 1
	// 1 -> 2
	// -2 -> 3
	// ... -> ...
	// 2147483647 -> 4294967294
	// -2147483648 -> 4294967295
	//
	// >> encode >>
	// << decode <<
	public static function zigZagEncode32($int32)
	{
	if (PHP_INT_SIZE == 8) {
	$trim_int32 = $int32 & 0xFFFFFFFF;
	return (($trim_int32 << 1) ^ ($int32 << 32 >> 63)) & 0xFFFFFFFF;
	} else {
	return ($int32 << 1) ^ ($int32 >> 31);
	}
	}

	public static function zigZagDecode32($uint32)
	{
	// Fill high 32 bits.
	if (PHP_INT_SIZE === 8) {
	$uint32 \|= ($uint32 & 0xFFFFFFFF);
	}

	$int32 = (($uint32 >> 1) & 0x7FFFFFFF) ^ (-($uint32 & 1));

	return $int32;
	}

	public static function zigZagEncode64($int64)
	{
	if (PHP_INT_SIZE == 4) {
	if (bccomp($int64, 0) >= 0) {
	return bcmul($int64, 2);
	} else {
	return bcsub(bcmul(bcsub(0, $int64), 2), 1);
	}
	} else {
	return ($int64 << 1) ^ ($int64 >> 63);
	}
	}

	public static function zigZagDecode64($uint64)
	{
	if (PHP_INT_SIZE == 4) {
	if (bcmod($uint64, 2) == 0) {
	return bcdiv($uint64, 2, 0);
	} else {
	return bcsub(0, bcdiv(bcadd($uint64, 1), 2, 0));
	}
	} else {
	return (($uint64 >> 1) & 0x7FFFFFFFFFFFFFFF) ^ (-($uint64 & 1));
	}
	}

	public static function readInt32(&$input, &$value)
	{
	return $input->readVarint32($value);
	}

	public static function readInt64(&$input, &$value)
	{
	$success = $input->readVarint64($value);
	if (PHP_INT_SIZE == 4 && bccomp($value, "9223372036854775807") > 0) {
	$value = bcsub($value, "18446744073709551616");
	}
	return $success;
	}

	public static function readUint32(&$input, &$value)
	{
	return self::readInt32($input, $value);
	}

	public static function readUint64(&$input, &$value)
	{
	return self::readInt64($input, $value);
	}

	public static function readSint32(&$input, &$value)
	{
	if (!$input->readVarint32($value)) {
	return false;
	}
	$value = GPBWire::zigZagDecode32($value);
	return true;
	}

	public static function readSint64(&$input, &$value)
	{
	if (!$input->readVarint64($value)) {
	return false;
	}
	$value = GPBWire::zigZagDecode64($value);
	return true;
	}

	public static function readFixed32(&$input, &$value)
	{
	return $input->readLittleEndian32($value);
	}

	public static function readFixed64(&$input, &$value)
	{
	return $input->readLittleEndian64($value);
	}

	public static function readSfixed32(&$input, &$value)
	{
	if (!self::readFixed32($input, $value)) {
	return false;
	}
	if (PHP_INT_SIZE === 8) {
	$value \|= (-($value >> 31) << 32);
	}
	return true;
	}

	public static function readSfixed64(&$input, &$value)
	{
	$success = $input->readLittleEndian64($value);
	if (PHP_INT_SIZE == 4 && bccomp($value, "9223372036854775807") > 0) {
	$value = bcsub($value, "18446744073709551616");
	}
	return $success;
	}

	public static function readFloat(&$input, &$value)
	{
	$data = null;
	if (!$input->readRaw(4, $data)) {
	return false;
	}
	$value = unpack('f', $data)[1];
	return true;
	}

	public static function readDouble(&$input, &$value)
	{
	$data = null;
	if (!$input->readRaw(8, $data)) {
	return false;
	}
	$value = unpack('d', $data)[1];
	return true;
	}

	public static function readBool(&$input, &$value)
	{
	if (!$input->readVarint64($value)) {
	return false;
	}
	if ($value == 0) {
	$value = false;
	} else {
	$value = true;
	}
	return true;
	}

	public static function readString(&$input, &$value)
	{
	$length = 0;
	return $input->readVarintSizeAsInt($length) && $input->readRaw($length, $value);
	}

	public static function readMessage(&$input, &$message)
	{
	$length = 0;
	if (!$input->readVarintSizeAsInt($length)) {
	return false;
	}
	$old_limit = 0;
	$recursion_limit = 0;
	$input->incrementRecursionDepthAndPushLimit(
	$length,
	$old_limit,
	$recursion_limit);
	if ($recursion_limit < 0 \|\| !$message->parseFromStream($input)) {
	return false;
	}
	return $input->decrementRecursionDepthAndPopLimit($old_limit);
	}

	public static function writeTag(&$output, $tag)
	{
	return $output->writeTag($tag);
	}

	public static function writeInt32(&$output, $value)
	{
	return $output->writeVarint32($value, false);
	}

	public static function writeInt64(&$output, $value)
	{
	return $output->writeVarint64($value);
	}

	public static function writeUint32(&$output, $value)
	{
	return $output->writeVarint32($value, true);
	}

	public static function writeUint64(&$output, $value)
	{
	return $output->writeVarint64($value);
	}

	public static function writeSint32(&$output, $value)
	{
	$value = GPBWire::zigZagEncode32($value);
	return $output->writeVarint32($value, true);
	}

	public static function writeSint64(&$output, $value)
	{
	$value = GPBWire::zigZagEncode64($value);
	return $output->writeVarint64($value);
	}

	public static function writeFixed32(&$output, $value)
	{
	return $output->writeLittleEndian32($value);
	}

	public static function writeFixed64(&$output, $value)
	{
	return $output->writeLittleEndian64($value);
	}

	public static function writeSfixed32(&$output, $value)
	{
	return $output->writeLittleEndian32($value);
	}

	public static function writeSfixed64(&$output, $value)
	{
	return $output->writeLittleEndian64($value);
	}

	public static function writeBool(&$output, $value)
	{
	if ($value) {
	return $output->writeVarint32(1, true);
	} else {
	return $output->writeVarint32(0, true);
	}
	}

	public static function writeFloat(&$output, $value)
	{
	$data = pack("f", $value);
	return $output->writeRaw($data, 4);
	}

	public static function writeDouble(&$output, $value)
	{
	$data = pack("d", $value);
	return $output->writeRaw($data, 8);
	}

	public static function writeString(&$output, $value)
	{
	return self::writeBytes($output, $value);
	}

	public static function writeBytes(&$output, $value)
	{
	$size = strlen($value);
	if (!$output->writeVarint32($size, true)) {
	return false;
	}
	return $output->writeRaw($value, $size);
	}

	public static function writeMessage(&$output, $value)
	{
	$size = $value->byteSize();
	if (!$output->writeVarint32($size, true)) {
	return false;
	}
	return $value->serializeToStream($output);
	}

	public static function makeTag($number, $type)
	{
	return ($number << 3) \| self::getWireType($type);
	}

	public static function tagSize($field)
	{
	$tag = self::makeTag($field->getNumber(), $field->getType());
	return self::varint32Size($tag);
	}

	public static function varint32Size($value, $sign_extended = false)
	{
	if ($value < 0) {
	if ($sign_extended) {
	return 10;
	} else {
	return 5;
	}
	}
	if ($value < (1 << 7)) {
	return 1;
	}
	if ($value < (1 << 14)) {
	return 2;
	}
	if ($value < (1 << 21)) {
	return 3;
	}
	if ($value < (1 << 28)) {
	return 4;
	}
	return 5;
	}

	public static function sint32Size($value)
	{
	$value = self::zigZagEncode32($value);
	return self::varint32Size($value);
	}

	public static function sint64Size($value)
	{
	$value = self::zigZagEncode64($value);
	return self::varint64Size($value);
	}

	public static function varint64Size($value)
	{
	if (PHP_INT_SIZE == 4) {
	if (bccomp($value, 0) < 0 \|\|
	bccomp($value, "9223372036854775807") > 0) {
	return 10;
	}
	if (bccomp($value, 1 << 7) < 0) {
	return 1;
	}
	if (bccomp($value, 1 << 14) < 0) {
	return 2;
	}
	if (bccomp($value, 1 << 21) < 0) {
	return 3;
	}
	if (bccomp($value, 1 << 28) < 0) {
	return 4;
	}
	if (bccomp($value, '34359738368') < 0) {
	return 5;
	}
	if (bccomp($value, '4398046511104') < 0) {
	return 6;
	}
	if (bccomp($value, '562949953421312') < 0) {
	return 7;
	}
	if (bccomp($value, '72057594037927936') < 0) {
	return 8;
	}
	return 9;
	} else {
	if ($value < 0) {
	return 10;
	}
	if ($value < (1 << 7)) {
	return 1;
	}
	if ($value < (1 << 14)) {
	return 2;
	}
	if ($value < (1 << 21)) {
	return 3;
	}
	if ($value < (1 << 28)) {
	return 4;
	}
	if ($value < (1 << 35)) {
	return 5;
	}
	if ($value < (1 << 42)) {
	return 6;
	}
	if ($value < (1 << 49)) {
	return 7;
	}
	if ($value < (1 << 56)) {
	return 8;
	}
	return 9;
	}
	}

	public static function serializeFieldToStream(
	$value,
	$field,
	$need_tag,
	&$output)
	{
	if ($need_tag) {
	if (!GPBWire::writeTag(
	$output,
	self::makeTag(
	$field->getNumber(),
	$field->getType()))) {
	return false;
	}
	}
	switch ($field->getType()) {
	case GPBType::DOUBLE:
	if (!GPBWire::writeDouble($output, $value)) {
	return false;
	}
	break;
	case GPBType::FLOAT:
	if (!GPBWire::writeFloat($output, $value)) {
	return false;
	}
	break;
	case GPBType::INT64:
	if (!GPBWire::writeInt64($output, $value)) {
	return false;
	}
	break;
	case GPBType::UINT64:
	if (!GPBWire::writeUint64($output, $value)) {
	return false;
	}
	break;
	case GPBType::INT32:
	if (!GPBWire::writeInt32($output, $value)) {
	return false;
	}
	break;
	case GPBType::FIXED32:
	if (!GPBWire::writeFixed32($output, $value)) {
	return false;
	}
	break;
	case GPBType::FIXED64:
	if (!GPBWire::writeFixed64($output, $value)) {
	return false;
	}
	break;
	case GPBType::BOOL:
	if (!GPBWire::writeBool($output, $value)) {
	return false;
	}
	break;
	case GPBType::STRING:
	if (!GPBWire::writeString($output, $value)) {
	return false;
	}
	break;
	// case GPBType::GROUP:
	// echo "GROUP\xA";
	// trigger_error("Not implemented.", E_ERROR);
	// break;
	case GPBType::MESSAGE:
	if (!GPBWire::writeMessage($output, $value)) {
	return false;
	}
	break;
	case GPBType::BYTES:
	if (!GPBWire::writeBytes($output, $value)) {
	return false;
	}
	break;
	case GPBType::UINT32:
	if (PHP_INT_SIZE === 8 && $value < 0) {
	$value += 4294967296;
	}
	if (!GPBWire::writeUint32($output, $value)) {
	return false;
	}
	break;
	case GPBType::ENUM:
	if (!GPBWire::writeInt32($output, $value)) {
	return false;
	}
	break;
	case GPBType::SFIXED32:
	if (!GPBWire::writeSfixed32($output, $value)) {
	return false;
	}
	break;
	case GPBType::SFIXED64:
	if (!GPBWire::writeSfixed64($output, $value)) {
	return false;
	}
	break;
	case GPBType::SINT32:
	if (!GPBWire::writeSint32($output, $value)) {
	return false;
	}
	break;
	case GPBType::SINT64:
	if (!GPBWire::writeSint64($output, $value)) {
	return false;
	}
	break;
	default:
	user_error("Unsupported type.");
	return false;
	}

	return true;
	}
	}