ProtocolBuffers/CodecIV32.pm untested

filter: Statementstmt 0.0% 0 / 67 Branchbran 0.0% 0 / 30 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 13 Podpod 0.0% 0 / 8 totaltotal 0.0% 0 / 118 CC 16 SCAR 26.4
CC
16
Cov
0%
decode_varint
30.0
encode_sint
20.0
decode_sfixed64
20.0
CRAP 14.1
1 ##
2 ## Warning, despite name of the file, subrotines from here belongs
3 ## to Google::ProtocolBuffers::Codec namespace
4 ##
5 package Google::ProtocolBuffers::Codec;
6 use strict;
7 use warnings FATAL => 'substr';
8 use Math::BigInt;
9 use constant TWO_IN_64 => Math::BigInt->new("0x1_0000_0000_0000_0000");
10 use constant MAX_SINT64 => Math::BigInt->new( "0x7FFF_FFFF_FFFF_FFFF");
11
12
13 ## Signature of all encode_* subs:
14 ## encode_*($buffer, $value);
15 ## Encoded value of $value will be appended to $buffer, which is a string
16 ## passed by reference. No meaningfull value is returned, in case of errors
17 ## an exception it thrown.
18 ##
19 ## Signature of all encode_* subs:
20 ## my $value = decode_*($buffer, $position);
21 ## $buffer is a string passed by reference, no copy is performed and it
22 ## is not modified. $position is a number variable passed by reference
23 ## (index in the string $buffer where to start decoding of a value), it
24 ## is incremented by decode_* subs. In case of errors an exception is
25 ## thrown.
26
27 sub decode_varint {
28 my $v = 0;
29 my $shift = 0;
30 my $l = length($_[0]);
31 while (1) {
32 die BROKEN_MESSAGE() if $_[1] >= $l; ## if $_[1]+1 > $l
33 my $b = ord(substr($_[0], $_[1]++, 1));
34 if ($shift==28) {
35 $shift = Math::BigInt->new($shift);
36 }
37 $v += (($b & 0x7F) << $shift);
38 $shift += 7;
39 last if ($b & 0x80)==0;
40 die "Number is too long" if $shift > 63;
41 }
42 return $v;
43 }
44
45 sub encode_int {
46 if ($_[1]>=0) {
47 encode_varint($_[0], $_[1]);
48 } else {
49 ## We need a positive 64 bit integer, which bit representation is
50 ## the same as of this negative value, static_cast<uint64>(int64).
51 ## 2^64 + $v === (2^64-1) + $v + 1, for $v<0
52 encode_varint($_[0], (TWO_IN_64+$_[1]));
53 }
54 }
55
56 sub decode_int {
57 my $v = decode_varint(@_);
58 if ($v>MAX_SINT64) {
59 return ($v - TWO_IN_64);
60 } else {
61 return $v;
62 }
63 }
64
65 ##
66 ## $_[1]<<1 is subject to overflow: a value that fit into
67 ## Perl's int (IV) may need unsigned int (UV) to fit,
68 ## and I don't know how to make Perl do that cast.
69 ##
70 sub encode_sint {
71 if ($_[1]>=MAX_SINT32()) {
72 encode_varint($_[0], Math::BigInt->new($_[1])<<1);
73 } elsif ($_[1]<=MIN_SINT32()) {
74 encode_varint($_[0], ((-Math::BigInt->new($_[1]))<<1)-1);
75 } elsif ($_[1]>=0) {
76 encode_varint($_[0], $_[1]<<1);
77 } else {
78 encode_varint($_[0], ((-$_[1])<<1)-1);
79 }
80 }
81
82 sub encode_fixed64 {
83 $_[0] .= pack('V', $_[1] & 0xFFFF_FFFF);
84 $_[0] .= pack('V', ($_[1]>>16)>>16);
85 }
86 sub decode_fixed64 {
87 die BROKEN_MESSAGE() if $_[1]+8 > length($_[0]);
88 my $a = unpack('V', substr($_[0], $_[1], 4));
89 my $b = unpack('V', substr($_[0], $_[1]+4, 4));
90 $_[1] += 8;
91 if ($b==0) {
92 return $a
93 } else {
94 $b = Math::BigInt->new($b);
95 return $a | ($b<<32);
96 }
97 }
98
99 sub encode_sfixed64 {
100 if ($_[1]>=0) {
101 $_[0] .= pack('V', $_[1] & 0xFFFF_FFFF);
102 $_[0] .= pack('V', ($_[1]>>16)>>16);
103 } else {
104 ## We need a positive 64 bit integer, which bit representation is
105 ## the same as of this negative value, static_cast<uint64>(int64).
106 ## 2^64 + $v === (2^64-1) + $v + 1, for $v<0
107 my $v = (TWO_IN_64+$_[1]);
108 $_[0] .= pack('V', $v & 0xFFFF_FFFF);
109 $_[0] .= pack('V', ($v>>16)>>16);
110 }
111
112 }
113
114 sub decode_sfixed64 {
115 die BROKEN_MESSAGE() if $_[1]+8 > length($_[0]);
116 my $a = unpack('V', substr($_[0], $_[1], 4));
117 my $b = unpack('V', substr($_[0], $_[1]+4, 4));
118 $_[1] += 8;
119 if ($b==0) {
120 return $a;
121 } else {
122 $b = (Math::BigInt->new($b)<<32) | $a;
123 return ($b>MAX_SINT64()) ? $b-TWO_IN_64() : $b;
124 }
125 }
126
127 1;