| <?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; |
| } |
| } |