Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(65)

Side by Side Diff: third_party/protobuf/js/binary/decoder.js

Issue 2590803003: Revert "third_party/protobuf: Update to HEAD (83d681ee2c)" (Closed)
Patch Set: Created 3 years, 12 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Protocol Buffers - Google's data interchange format 1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved. 2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/ 3 // https://developers.google.com/protocol-buffers/
4 // 4 //
5 // Redistribution and use in source and binary forms, with or without 5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are 6 // modification, are permitted provided that the following conditions are
7 // met: 7 // met:
8 // 8 //
9 // * Redistributions of source code must retain the above copyright 9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer. 10 // notice, this list of conditions and the following disclaimer.
(...skipping 715 matching lines...) Expand 10 before | Expand all | Expand 10 after
726 * @return {number} The decoded zigzag varint. Precision will be lost if the 726 * @return {number} The decoded zigzag varint. Precision will be lost if the
727 * integer exceeds 2^53. 727 * integer exceeds 2^53.
728 */ 728 */
729 jspb.BinaryDecoder.prototype.readZigzagVarint64 = function() { 729 jspb.BinaryDecoder.prototype.readZigzagVarint64 = function() {
730 this.readSplitVarint64_(); 730 this.readSplitVarint64_();
731 return jspb.utils.joinZigzag64(this.tempLow_, this.tempHigh_); 731 return jspb.utils.joinZigzag64(this.tempLow_, this.tempHigh_);
732 }; 732 };
733 733
734 734
735 /** 735 /**
736 * Reads a signed, zigzag-encoded 64-bit varint from the binary stream and
737 * returns its valud as a string.
738 *
739 * Zigzag encoding is a modification of varint encoding that reduces the
740 * storage overhead for small negative integers - for more details on the
741 * format, see https://developers.google.com/protocol-buffers/docs/encoding
742 *
743 * @return {string} The decoded signed, zigzag-encoded 64-bit varint as a
744 * string.
745 */
746 jspb.BinaryDecoder.prototype.readZigzagVarint64String = function() {
747 // TODO(haberman): write lossless 64-bit zig-zag math.
748 var value = this.readZigzagVarint64();
749 return value.toString();
750 };
751
752
753 /**
754 * Reads a raw unsigned 8-bit integer from the binary stream. 736 * Reads a raw unsigned 8-bit integer from the binary stream.
755 * 737 *
756 * @return {number} The unsigned 8-bit integer read from the binary stream. 738 * @return {number} The unsigned 8-bit integer read from the binary stream.
757 */ 739 */
758 jspb.BinaryDecoder.prototype.readUint8 = function() { 740 jspb.BinaryDecoder.prototype.readUint8 = function() {
759 var a = this.bytes_[this.cursor_ + 0]; 741 var a = this.bytes_[this.cursor_ + 0];
760 this.cursor_ += 1; 742 this.cursor_ += 1;
761 goog.asserts.assert(this.cursor_ <= this.end_); 743 goog.asserts.assert(this.cursor_ <= this.end_);
762 return a; 744 return a;
763 }; 745 };
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
802 * Precision will be lost if the integer exceeds 2^53. 784 * Precision will be lost if the integer exceeds 2^53.
803 */ 785 */
804 jspb.BinaryDecoder.prototype.readUint64 = function() { 786 jspb.BinaryDecoder.prototype.readUint64 = function() {
805 var bitsLow = this.readUint32(); 787 var bitsLow = this.readUint32();
806 var bitsHigh = this.readUint32(); 788 var bitsHigh = this.readUint32();
807 return jspb.utils.joinUint64(bitsLow, bitsHigh); 789 return jspb.utils.joinUint64(bitsLow, bitsHigh);
808 }; 790 };
809 791
810 792
811 /** 793 /**
812 * Reads a raw unsigned 64-bit integer from the binary stream. Note that since
813 * Javascript represents all numbers as double-precision floats, there will be
814 * precision lost if the absolute value of the integer is larger than 2^53.
815 *
816 * @return {string} The unsigned 64-bit integer read from the binary stream.
817 */
818 jspb.BinaryDecoder.prototype.readUint64String = function() {
819 var bitsLow = this.readUint32();
820 var bitsHigh = this.readUint32();
821 return jspb.utils.joinUnsignedDecimalString(bitsLow, bitsHigh);
822 };
823
824
825 /**
826 * Reads a raw signed 8-bit integer from the binary stream. 794 * Reads a raw signed 8-bit integer from the binary stream.
827 * 795 *
828 * @return {number} The signed 8-bit integer read from the binary stream. 796 * @return {number} The signed 8-bit integer read from the binary stream.
829 */ 797 */
830 jspb.BinaryDecoder.prototype.readInt8 = function() { 798 jspb.BinaryDecoder.prototype.readInt8 = function() {
831 var a = this.bytes_[this.cursor_ + 0]; 799 var a = this.bytes_[this.cursor_ + 0];
832 this.cursor_ += 1; 800 this.cursor_ += 1;
833 goog.asserts.assert(this.cursor_ <= this.end_); 801 goog.asserts.assert(this.cursor_ <= this.end_);
834 return (a << 24) >> 24; 802 return (a << 24) >> 24;
835 }; 803 };
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
874 * Precision will be lost if the integer exceeds 2^53. 842 * Precision will be lost if the integer exceeds 2^53.
875 */ 843 */
876 jspb.BinaryDecoder.prototype.readInt64 = function() { 844 jspb.BinaryDecoder.prototype.readInt64 = function() {
877 var bitsLow = this.readUint32(); 845 var bitsLow = this.readUint32();
878 var bitsHigh = this.readUint32(); 846 var bitsHigh = this.readUint32();
879 return jspb.utils.joinInt64(bitsLow, bitsHigh); 847 return jspb.utils.joinInt64(bitsLow, bitsHigh);
880 }; 848 };
881 849
882 850
883 /** 851 /**
884 * Reads a raw signed 64-bit integer from the binary stream and returns it as a
885 * string.
886 *
887 * @return {string} The signed 64-bit integer read from the binary stream.
888 * Precision will be lost if the integer exceeds 2^53.
889 */
890 jspb.BinaryDecoder.prototype.readInt64String = function() {
891 var bitsLow = this.readUint32();
892 var bitsHigh = this.readUint32();
893 return jspb.utils.joinSignedDecimalString(bitsLow, bitsHigh);
894 };
895
896
897 /**
898 * Reads a 32-bit floating-point number from the binary stream, using the 852 * Reads a 32-bit floating-point number from the binary stream, using the
899 * temporary buffer to realign the data. 853 * temporary buffer to realign the data.
900 * 854 *
901 * @return {number} The float read from the binary stream. 855 * @return {number} The float read from the binary stream.
902 */ 856 */
903 jspb.BinaryDecoder.prototype.readFloat = function() { 857 jspb.BinaryDecoder.prototype.readFloat = function() {
904 var bitsLow = this.readUint32(); 858 var bitsLow = this.readUint32();
905 var bitsHigh = 0; 859 var bitsHigh = 0;
906 return jspb.utils.joinFloat32(bitsLow, bitsHigh); 860 return jspb.utils.joinFloat32(bitsLow, bitsHigh);
907 }; 861 };
(...skipping 26 matching lines...) Expand all
934 * signed varints. 888 * signed varints.
935 * @return {number} The enum value read from the binary stream. 889 * @return {number} The enum value read from the binary stream.
936 */ 890 */
937 jspb.BinaryDecoder.prototype.readEnum = function() { 891 jspb.BinaryDecoder.prototype.readEnum = function() {
938 return this.readSignedVarint32(); 892 return this.readSignedVarint32();
939 }; 893 };
940 894
941 895
942 /** 896 /**
943 * Reads and parses a UTF-8 encoded unicode string from the stream. 897 * Reads and parses a UTF-8 encoded unicode string from the stream.
944 * The code is inspired by maps.vectortown.parse.StreamedDataViewReader. 898 * The code is inspired by maps.vectortown.parse.StreamedDataViewReader, with
945 * Supports codepoints from U+0000 up to U+10FFFF. 899 * the exception that the implementation here does not get confused if it
946 * (http://en.wikipedia.org/wiki/UTF-8). 900 * encounters characters longer than three bytes. These characters are ignored
901 * though, as they are extremely rare: three UTF-8 bytes cover virtually all
902 * characters in common use (http://en.wikipedia.org/wiki/UTF-8).
947 * @param {number} length The length of the string to read. 903 * @param {number} length The length of the string to read.
948 * @return {string} The decoded string. 904 * @return {string} The decoded string.
949 */ 905 */
950 jspb.BinaryDecoder.prototype.readString = function(length) { 906 jspb.BinaryDecoder.prototype.readString = function(length) {
951 var bytes = this.bytes_; 907 var bytes = this.bytes_;
952 var cursor = this.cursor_; 908 var cursor = this.cursor_;
953 var end = cursor + length; 909 var end = cursor + length;
954 var codeUnits = []; 910 var chars = [];
955 911
956 while (cursor < end) { 912 while (cursor < end) {
957 var c = bytes[cursor++]; 913 var c = bytes[cursor++];
958 if (c < 128) { // Regular 7-bit ASCII. 914 if (c < 128) { // Regular 7-bit ASCII.
959 codeUnits.push(c); 915 chars.push(c);
960 } else if (c < 192) { 916 } else if (c < 192) {
961 // UTF-8 continuation mark. We are out of sync. This 917 // UTF-8 continuation mark. We are out of sync. This
962 // might happen if we attempted to read a character 918 // might happen if we attempted to read a character
963 // with more than four bytes. 919 // with more than three bytes.
964 continue; 920 continue;
965 } else if (c < 224) { // UTF-8 with two bytes. 921 } else if (c < 224) { // UTF-8 with two bytes.
966 var c2 = bytes[cursor++]; 922 var c2 = bytes[cursor++];
967 codeUnits.push(((c & 31) << 6) | (c2 & 63)); 923 chars.push(((c & 31) << 6) | (c2 & 63));
968 } else if (c < 240) { // UTF-8 with three bytes. 924 } else if (c < 240) { // UTF-8 with three bytes.
969 var c2 = bytes[cursor++]; 925 var c2 = bytes[cursor++];
970 var c3 = bytes[cursor++]; 926 var c3 = bytes[cursor++];
971 codeUnits.push(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)); 927 chars.push(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
972 } else if (c < 248) { // UTF-8 with 4 bytes.
973 var c2 = bytes[cursor++];
974 var c3 = bytes[cursor++];
975 var c4 = bytes[cursor++];
976 // Characters written on 4 bytes have 21 bits for a codepoint.
977 // We can't fit that on 16bit characters, so we use surrogates.
978 var codepoint = ((c & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | ( c4 & 63);
979 // Surrogates formula from wikipedia.
980 // 1. Subtract 0x10000 from codepoint
981 codepoint -= 0x10000;
982 // 2. Split this into the high 10-bit value and the low 10-bit value
983 // 3. Add 0xD800 to the high value to form the high surrogate
984 // 4. Add 0xDC00 to the low value to form the low surrogate:
985 var low = (codepoint & 1023) + 0xDC00;
986 var high = ((codepoint >> 10) & 1023) + 0xD800;
987 codeUnits.push(high, low)
988 } 928 }
989 } 929 }
930
990 // String.fromCharCode.apply is faster than manually appending characters on 931 // String.fromCharCode.apply is faster than manually appending characters on
991 // Chrome 25+, and generates no additional cons string garbage. 932 // Chrome 25+, and generates no additional cons string garbage.
992 var result = String.fromCharCode.apply(null, codeUnits); 933 var result = String.fromCharCode.apply(null, chars);
993 this.cursor_ = cursor; 934 this.cursor_ = cursor;
994 return result; 935 return result;
995 }; 936 };
996 937
997 938
998 /** 939 /**
999 * Reads and parses a UTF-8 encoded unicode string (with length prefix) from 940 * Reads and parses a UTF-8 encoded unicode string (with length prefix) from
1000 * the stream. 941 * the stream.
1001 * @return {string} The decoded string. 942 * @return {string} The decoded string.
1002 */ 943 */
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after
1057 var d = bytes[cursor + 3]; 998 var d = bytes[cursor + 3];
1058 var e = bytes[cursor + 4]; 999 var e = bytes[cursor + 4];
1059 var f = bytes[cursor + 5]; 1000 var f = bytes[cursor + 5];
1060 var g = bytes[cursor + 6]; 1001 var g = bytes[cursor + 6];
1061 var h = bytes[cursor + 7]; 1002 var h = bytes[cursor + 7];
1062 1003
1063 this.cursor_ += 8; 1004 this.cursor_ += 8;
1064 1005
1065 return String.fromCharCode(a, b, c, d, e, f, g, h); 1006 return String.fromCharCode(a, b, c, d, e, f, g, h);
1066 }; 1007 };
OLDNEW
« no previous file with comments | « third_party/protobuf/js/binary/constants.js ('k') | third_party/protobuf/js/binary/decoder_test.js » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698