├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── edit_warning.txt
├── strip_xdelta3_decoder.sh
├── tests
├── debug.js
├── misc.js
├── style.css
├── testA.html
├── testA
│ ├── A.delta
│ ├── A.expectedTarget
│ └── A.source
├── testB.html
├── testB
│ ├── B.delta
│ └── B.expectedTarget
├── testC.html
├── testC
│ ├── C.delta
│ └── C.expectedTarget
├── testD.html
├── testD
│ ├── D.delta
│ ├── D.expectedTarget
│ └── D.source
├── testE.html
└── testE
│ ├── E.delta
│ ├── E.expectedTarget
│ └── E.source
├── xdelta3-decode_with_debug.h
├── xdelta3_decoder.js
├── xdelta3_decoder_with_debug.js
└── xdelta3_with_debug.c
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # How to contribute
2 |
3 | We'd love to accept your patches and contributions to this project. There are
4 | just a few small guidelines you need to follow.
5 |
6 | ## Contributor License Agreement
7 |
8 | Contributions to this project must be accompanied by a Contributor License
9 | Agreement. You (or your employer) retain the copyright to your contribution,
10 | this simply gives us permission to use and redistribute your contributions as
11 | part of the project. Head over to ' + name + ': ' + path + ' XDelta3 TestA: text with source
5 | XDelta3 TestB: text/no-source
5 | XDelta3 TestC: binary/no-source
5 | XDelta3 TestD: big binary with source
5 | XDelta3 TestE: big binary with source and secondary compressor
5 | } tableRows
560 | * @constructor
561 | * @struct
562 | */
563 | var xd3_dinst_table = function(tableRows) {
564 | /** @type {!Array} */
565 | this.tableRows = tableRows;
566 | };
567 |
568 | /**
569 | * xd3_hinst
570 | * @constructor
571 | */
572 | function xd3_hinst() {
573 | this.type = XD3_NOOP;
574 | this.size = 0;
575 | this.addr = 0;
576 | }
577 |
578 | /**
579 | * The code-table double instruction.
580 | * @constructor
581 | */
582 | function xd3_dinst() {
583 | /** @type {number} */
584 | this.type1 = XD3_NOOP;
585 | /** @type {number} */
586 | this.size1 = 0;
587 | /** @type {number} */
588 | this.type2 = XD3_NOOP;
589 | /** @type {number} */
590 | this.size2 = 0;
591 | }
592 |
593 | /**
594 | * @param {!xd3_code_table_desc} desc
595 | * @return {!xd3_dinst_table}
596 | */
597 | function xd3_build_code_table(desc) {
598 | var row = 0;
599 | var tableRows = new Array(256);
600 | for (var i = 0; i < 256; i++) {
601 | tableRows[i] = new xd3_dinst();
602 | }
603 | var cpyModes = 2 + desc.near_modes + desc.same_modes;
604 |
605 | // The single RUN command.
606 | tableRows[row++].type1 = XD3_RUN;
607 |
608 | // The ADD only commands.
609 | tableRows[row++].type1 = XD3_ADD;
610 | for (var size1 = 1; size1 <= desc.add_sizes; size1++) {
611 | tableRows[row].type1 = XD3_ADD;
612 | tableRows[row++].size1 = size1;
613 | }
614 |
615 | // The Copy only commands.
616 | for (var mode = 0; mode < cpyModes; mode++) {
617 | tableRows[row++].type1 = XD3_CPY + mode;
618 |
619 | for (var size1 = MIN_MATCH; size1 < MIN_MATCH + desc.cpy_sizes; size1++) {
620 | tableRows[row].type1 = XD3_CPY + mode;
621 | tableRows[row++].size1 = size1;
622 | }
623 | }
624 |
625 | // The Add/Copy commands.
626 | for (var mode = 0; mode < cpyModes; mode++) {
627 | for (var size1 = 1; size1 <= desc.addcopy_add_max; size1++) {
628 | var max = (mode < 2 + desc.near_modes) ? //
629 | desc.addcopy_near_cpy_max :
630 | desc.addcopy_same_cpy_max;
631 | for (var size2 = MIN_MATCH; size2 <= max; size2++) {
632 | tableRows[row].type1 = XD3_ADD;
633 | tableRows[row].size1 = size1;
634 | tableRows[row].type2 = XD3_CPY + mode;
635 | tableRows[row++].size2 = size2;
636 | }
637 | }
638 | }
639 |
640 | // The Copy/Add commands.
641 | for (var mode = 0; mode < cpyModes; mode++) {
642 | var max = (mode < 2 + desc.near_modes) ? //
643 | desc.copyadd_near_cpy_max :
644 | desc.copyadd_same_cpy_max;
645 | for (var size1 = MIN_MATCH; size1 <= max; size1++) {
646 | for (var size2 = 1; size2 <= desc.copyadd_add_max; size2++) {
647 | tableRows[row].type1 = XD3_CPY + mode;
648 | tableRows[row].size1 = size1;
649 | tableRows[row].type2 = XD3_ADD;
650 | tableRows[row++].size2 = size2;
651 | }
652 | }
653 | }
654 |
655 | return new xd3_dinst_table(tableRows);
656 | }
657 |
658 |
659 | /**
660 | * @constructor
661 | */
662 | function xd3_code_table_desc() {
663 | this.add_sizes = 0;
664 | this.near_modes = 0;
665 | this.same_modes = 0;
666 | this.cpy_sizes = 0;
667 |
668 | this.addcopy_add_max = 0;
669 | this.addcopy_near_cpy_max = 0;
670 | this.addcopy_same_cpy_max = 0;
671 |
672 | this.copyadd_add_max = 0;
673 | this.copyadd_near_cpy_max = 0;
674 | this.copyadd_same_cpy_max = 0;
675 | }
676 |
677 |
678 | /**
679 | * This builds the __rfc3284_code_table_desc
680 | * Assumes a single RUN instruction
681 | * Assumes that MIN_MATCH is 4.
682 | * @return {!xd3_code_table_desc}
683 | */
684 | function build_rfc3284_code_table_desc() {
685 | var desc = new xd3_code_table_desc();
686 | desc.add_sizes = 17;
687 | desc.near_modes = 4;
688 | desc.same_modes = 3;
689 | desc.cpy_sizes = 15;
690 |
691 | desc.addcopy_add_max = 4;
692 | desc.addcopy_near_cpy_max = 6;
693 | desc.addcopy_same_cpy_max = 4;
694 |
695 | desc.copyadd_add_max = 1;
696 | desc.copyadd_near_cpy_max = 4;
697 | desc.copyadd_same_cpy_max = 4;
698 |
699 | // xd3_code_table_sizes addcopy_max_sizes[MAX_MODES];
700 | // { {6,163,3},{6,175,3},{6,187,3},{6,199,3},{6,211,3},{6,223,3},
701 | // {4,235,1},{4,239,1},{4,243,1} },
702 |
703 | // xd3_code_table_sizes copyadd_max_sizes[MAX_MODES];
704 | // { {4,247,1},{4,248,1},{4,249,1},{4,250,1},{4,251,1},{4,252,1},
705 | // {4,253,1},{4,254,1},{4,255,1} },
706 |
707 | return desc;
708 | }
709 |
710 | var __rfc3284_code_table_desc = build_rfc3284_code_table_desc();
711 |
712 | var A32_BASE = 65521; /* Largest prime smaller than 2^16 */
713 | var A32_NMAX = 5552; /* NMAX is the largest n such that 255n(n+1)/2
714 | + (n+1)(BASE-1) <= 2^32-1 */
715 |
716 | // 1140 #define A32_DO1(buf,i) {s1 += buf[i]; s2 += s1;}
717 | // 1141 #define A32_DO2(buf,i) A32_DO1(buf,i); A32_DO1(buf,i+1);
718 | // 1142 #define A32_DO4(buf,i) A32_DO2(buf,i); A32_DO2(buf,i+2);
719 | // 1143 #define A32_DO8(buf,i) A32_DO4(buf,i); A32_DO4(buf,i+4);
720 | // 1144 #define A32_DO16(buf) A32_DO8(buf,0); A32_DO8(buf,8);
721 |
722 |
723 | /**
724 | * Calculated the Adler32 checksum.
725 | * @param {number} adler I'm not sure what this is.
726 | * @param {!Uint8Array} buf
727 | * @param {number} pos
728 | * @param {number} len
729 | * @return {number}
730 | */
731 | function adler32(adler, buf, pos, len) {
732 | var s1 = adler & 0xffff;
733 | var s2 = (adler >> 16) & 0xffff;
734 | var k;
735 |
736 | while (len > 0) {
737 | k = (len < A32_NMAX) ? len : A32_NMAX;
738 | len -= k;
739 |
740 | if (k != 0) {
741 | do {
742 | s1 += buf[pos++];
743 | s2 += s1;
744 | } while (--k);
745 | }
746 |
747 | s1 %= A32_BASE;
748 | s2 %= A32_BASE;
749 | }
750 |
751 | return (s2 << 16) | s1;
752 | }
753 |
754 |
755 | /**
756 | * @constructor
757 | */
758 | function xd3_addr_cache(s_near, s_same) {
759 | this.s_near = s_near;
760 | this.s_same = s_same;
761 | this.next_slot = 0; /* the circular index for near */
762 | this.near_array = null; /* array of size s_near */
763 | this.same_array = null; /* array of size s_same*256 */
764 | }
765 |
766 |
767 | /**
768 | * @param {!xd3_addr_cache} acache
769 | */
770 | function xd3_init_cache(acache) {
771 | if (acache.s_near > 0) {
772 | for (var i = 0; i < acache.near_array.length; i++) {
773 | acache.near_array[i] = 0;
774 | }
775 | acache.next_slot = 0;
776 | }
777 |
778 | if (acache.s_same > 0) {
779 | for (var i = 0; i < acache.same_array.length; i++) {
780 | acache.same_array[i] = 0;
781 | }
782 | }
783 | }
784 |
785 | /**
786 | * Used by the decoder to buffer input in sections.
787 | * XDelta3 C++ struct.
788 | * @constructor
789 | * @struct
790 | */
791 | function xd3_desect() {
792 | /**
793 | * The buffer as a slice of the backingBuffer;
794 | * @type {?Uint8Array}
795 | */
796 | this.bytes = null;
797 |
798 | /** @type {number} */
799 | this.size = 0;
800 |
801 | /** @type {number} */
802 | this.pos = 0;
803 | }
804 |
805 | /**
806 | * Gets a byte from the section.
807 | * @return {number}
808 | */
809 | xd3_desect.prototype.getByte = function() {
810 | if (!this.bytes) {
811 | throw new Error('bytes not set');
812 | }
813 | return this.bytes[this.pos++];
814 | };
815 |
816 | /**
817 | * Gets an integer from the section.
818 | * XDelta3 integers are encodes as a variable number of 7 bit bytes. Bit 8, the
819 | * most significant bit is used to indicate more bytes needed.
820 | * @return {number}
821 | */
822 | xd3_desect.prototype.getInteger = function() {
823 | if (!this.bytes) {
824 | throw new Error('bytes not set');
825 | }
826 | var val = 0;
827 | for (var i = 0; i < 10; i++) {
828 | var aByte = this.bytes[this.pos++];
829 | val += aByte & 0x7F;
830 | if (!(aByte & 0x80)) {
831 | return val;
832 | }
833 | val <<= 7;
834 | }
835 | throw new Error('invalid number');
836 | };
837 |
838 |
839 | /**
840 | * Builds a default code table.
841 | * @return {!xd3_dinst_table}
842 | */
843 | function xd3_rfc3284_code_table() {
844 | return xd3_build_code_table(__rfc3284_code_table_desc);
845 | }
846 |
847 | /**
848 | * Allocates and initializes a Javascript Array.
849 | * @return {!Array}
850 | */
851 | function allocArray(len, val) {
852 | var arr = new Array(len);
853 | for (var i = 0; i < len; i++) {
854 | arr[i] = val;
855 | }
856 | return arr;
857 | }
858 |
859 | /**
860 | * @constructor
861 | */
862 | function xd3_source() {
863 | /** @type {number} */
864 | this.cpyoff_blkoff = -1;
865 | }
866 |
867 | /**
868 | * @param {!Uint8Array} bytes
869 | * @constructor
870 | */
871 | function DataObject(bytes) {
872 | this.pos = 0;
873 | this.bytes = bytes;
874 | };
875 |
876 | DataObject.prototype.getByte = function() {
877 | return this.bytes[this.pos++];
878 | };
879 |
880 | DataObject.prototype.getInteger = function() {
881 | var val = 0;
882 | for (var i = 0; i < 10; i++) {
883 | var aByte = this.bytes[this.pos++];
884 | val += aByte & 0x7F;
885 | if (!(aByte & 0x80)) {
886 | return val;
887 | }
888 | val <<= 7;
889 | }
890 | throw new Error('invalid number');
891 | };
892 |
893 | DataObject.prototype.fill = function(val, length) {
894 | // TODO(bstell): see if there is a function for this.
895 | for (var i = 0; i < length; i++) {
896 | this.bytes[this.pos++] = val;
897 | }
898 | };
899 |
900 | /**
901 | * @param {!xd3_desect} sect
902 | * @param {number} length
903 | */
904 | DataObject.prototype.copySect = function(sect, length) {
905 | // TODO(bstell): see if there is a function for this.
906 | for (var i = 0; i < length; i++) {
907 | this.bytes[this.pos++] = sect.bytes[sect.pos++];
908 | }
909 | };
910 |
911 | DataObject.prototype.copyBytes = function(bytes, offset, length) {
912 | // TODO(bstell): see if there is a function for this.
913 | for (var i = 0; i < length; i++) {
914 | this.bytes[this.pos++] = bytes[offset++];
915 | }
916 | };
917 |
918 | })();
919 |
--------------------------------------------------------------------------------
/xdelta3_decoder_with_debug.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | /**
3 | * xdelta3 - delta compression tools and library
4 | * Copyright 2016 Joshua MacDonald
5 | *
6 | * Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
7 | * 2011, 2012, 2013, 2014, 2015 josh.macdonald@gmail.com
8 | *
9 | * Licensed under the Apache License, Version 2.0 (the "License");
10 | * you may not use this file except in compliance with the License.
11 | * You may obtain a copy of the License at
12 | *
13 | * http://www.apache.org/licenses/LICENSE-2.0
14 | *
15 | * Unless required by applicable law or agreed to in writing, software
16 | * distributed under the License is distributed on an "AS IS" BASIS,
17 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 | * See the License for the specific language governing permissions and
19 | * limitations under the License.
20 | */
21 |
22 | /**
23 | * @fileoverview This file implements XDelta3 decoding.
24 | * Note: the subroutine, method, field, and variable names do not follow
25 | * Javascript style guide but reflect the names in the XDelta3 C++ files. This
26 | * makes is to make it easier to keep this code in synch with the C++ code.
27 | *
28 | * The C++ code is very casual about initializing and accessing data structures.
29 | * This code is a port and follows that code style.
30 | */
31 |
32 | (function() {
33 |
34 | // Check for namespace collision.
35 | if ((typeof window['XDelta3Decoder'] != 'undefined')
36 | || (typeof window.XDelta3Decoder != 'undefined')) {
37 | throw new Error('XDelta3Decoder already defined.');
38 | }
39 |
40 | /**
41 | * The public class.
42 | */
43 | window.XDelta3Decoder = function(debugOutput) { //
44 | };
45 |
46 | var XDelta3Decoder = window.XDelta3Decoder;
47 |
48 | /**
49 | * The public API to decode a delta possibly with a source.
50 | * @param {!Uint8Array} delta The Xdelta delta file.
51 | * @param {Uint8Array=} opt_source The source file (optional).
52 | * @return {!ArrayBuffer}
53 | */
54 | XDelta3Decoder.decode = function(delta, opt_source) {
55 | if (typeof opt_source != 'object') {
56 | opt_source = null;
57 | }
58 | var xdelta3 = new _XDelta3Decoder(delta, opt_source);
59 | var uint8Bytes = xdelta3.xd3_decode_input();
60 | return uint8Bytes.buffer;
61 | }
62 |
63 | /**
64 | * The public API to disable debug printf code.
65 | */
66 | XDelta3Decoder.disableDebug = function() { // DEBUG ONLY
67 | for (var i = 0; i < fallbackRoutines.length; i++) { // DEBUG ONLY
68 | var name = fallbackRoutines[i]; // DEBUG ONLY
69 | window[name] = function() {}; // DEBUG ONLY
70 | } // DEBUG ONLY
71 | } // DEBUG ONLY
72 |
73 | // Define debug fallback routines if needed.
74 | var fallbackRoutines = [ // DEBUG ONLY
75 | 'dumpBytes', // DEBUG ONLY
76 | 'dumpCodeTableRows', // DEBUG ONLY
77 | 'printf', // DEBUG ONLY
78 | 'printInstructionPair', // DEBUG ONLY
79 | 'toHexStr' // DEBUG ONLY
80 | ]; // DEBUG ONLY
81 | for (var i = 0; i < fallbackRoutines.length; i++) { // DEBUG ONLY
82 | var name = fallbackRoutines[i]; // DEBUG ONLY
83 | if (typeof window[name] == 'undefined') { // DEBUG ONLY
84 | window[name] = function() {}; // DEBUG ONLY
85 | } // DEBUG ONLY
86 | } // DEBUG ONLY
87 |
88 | /**
89 | * The XDelta3 data commands.
90 | */
91 | /** @type {number} */
92 | var XD3_NOOP = 0;
93 | /** @type {number} */
94 | var XD3_ADD = 1;
95 | /** @type {number} */
96 | var XD3_RUN = 2;
97 | /** @type {number} */
98 | var XD3_CPY = 3;
99 |
100 | /** @type {number} */
101 | var MIN_MATCH = 4;
102 |
103 | /**
104 | * Header indicator bits.
105 | */
106 | /** @type {number} */
107 | var VCD_SECONDARY = 1;
108 | /** @type {number} */
109 | var VCD_CODETABLE = 2;
110 | /** @type {number} */
111 | var VCD_APPHEADER = 4;
112 | /** @type {number} */
113 | var VCD_INVHDR = ~(VCD_SECONDARY | VCD_CODETABLE | VCD_APPHEADER);
114 |
115 | var VCD_SOURCE = 0x01;
116 | var VCD_TARGET = 0x02;
117 | var VCD_ADLER32 = 0x04;
118 |
119 |
120 | /**
121 | * Declares the main decode class.
122 | * @param {!Uint8Array} delta The Xdelta3 delta file.
123 | * @param {Uint8Array=} opt_source The source file (optional).
124 | * @constructor
125 | */
126 | function _XDelta3Decoder(delta, opt_source) {
127 | /** @type {!Uint8Array} */
128 | this.delta = delta;
129 |
130 | var source = opt_source || new Uint8Array(1);
131 | /** @type {!DataObject} */
132 | this.source = new DataObject(source);
133 |
134 | /** @type {!xd3_source} */
135 | this.src = new xd3_source();
136 |
137 | /** @type {number} */
138 | this.position = 0;
139 |
140 | /** @type {number} */
141 | this.dec_window_count = 0;
142 |
143 | /** @type {number} */
144 | this.dec_winstart = 0;
145 |
146 | /**
147 | * The length of the target window.
148 | * @type {number}
149 | */
150 | this.dec_tgtlen = 0;
151 |
152 | /**
153 | * The Alder32 checksum. This is used to verify the decoded bytes checksum
154 | * matches the checksum of the original.
155 | */
156 | this.dec_adler32 = 0;
157 |
158 | /**
159 | * First half instruction.
160 | * @type {!xd3_hinst}
161 | */
162 | this.dec_current1 = new xd3_hinst();
163 |
164 | /**
165 | * Second half instruction.
166 | * @type {!xd3_hinst}
167 | */
168 | this.dec_current2 = new xd3_hinst();
169 |
170 | /** @type {!xd3_desect} */
171 | this.data_sect = new xd3_desect();
172 |
173 | /** @type {!xd3_desect} */
174 | this.inst_sect = new xd3_desect();
175 |
176 | /** @type {!xd3_desect} */
177 | this.addr_sect = new xd3_desect();
178 |
179 | /**
180 | * The address cache.
181 | * @type {!xd3_addr_cache}
182 | */
183 | this.acache = new xd3_addr_cache(
184 | __rfc3284_code_table_desc.near_modes,
185 | __rfc3284_code_table_desc.same_modes);
186 | }
187 |
188 | /**
189 | * Allocates the address caches.
190 | */
191 | _XDelta3Decoder.prototype.xd3_alloc_cache = function() {
192 | printf("xd3_alloc_cache\n"); // DEBUG ONLY
193 | this.acache.near_array = null; // not sure this is needed
194 | this.acache.same_array = null; // not sure this is needed
195 | if (this.acache.s_near > 0) {
196 | this.acache.near_array = allocArray(this.acache.s_near, 0);
197 | }
198 | if (this.acache.s_same > 0) {
199 | this.acache.same_array = allocArray(this.acache.s_same * 256, 0);
200 | }
201 | };
202 |
203 | /**
204 | * Parses the delta file data and produces the targetWindow data.
205 | * @return {!Uint8Array}
206 | */
207 | _XDelta3Decoder.prototype.xd3_decode_input = function() {
208 | printf("==================================\n"); // DEBUG ONLY
209 | printf(" HEADER pos = " + this.position + "\n"); // DEBUG ONLY
210 | printf("==================================\n"); // DEBUG ONLY
211 | printf("DEC_VCHEAD: load magic bytes\n"); // DEBUG ONLY
212 | dumpBytes(this.delta, 0, 4); // DEBUG ONLY
213 |
214 | printf("DEC_VCHEAD: check magic bytes\n"); // DEBUG ONLY
215 | if (this.delta[0] != 0xD6 || // 'V' with MSB set
216 | this.delta[1] != 0xC3 || // 'C' with MSB set
217 | this.delta[2] != 0xC4 || // 'D' with MSB set
218 | this.delta[3] != 0) { // unused but be set to zero
219 | throw new Error('XD3_INVALID_INPUT invalid magic');
220 | }
221 | this.position = 4;
222 |
223 | this.dec_hdr_ind = this.delta[this.position++];
224 | printf("DEC_HDRIND: dec_hdr_ind = " + toHexStr(this.dec_hdr_ind) + "\n"); // DEBUG ONLY
225 | if (this.dec_hdr_ind & VCD_INVHDR) {
226 | throw new Error('VCD_INVHDR unrecognized header indicator bits set');
227 | }
228 |
229 | printf("DEC_SECONDID: read byte if VCD_SECONDARY(" + (this.dec_hdr_ind & VCD_SECONDARY) + ")\n"); // DEBUG ONLY
230 | if (this.dec_hdr_ind & VCD_SECONDARY) {
231 | throw new Error('VCD_SECONDARY not implemented');
232 | }
233 | printf("DEC_TABLEN: read size if VCD_CODETABLE(" + (this.dec_hdr_ind & VCD_CODETABLE) + ")\n"); // DEBUG ONLY
234 | printf("DEC_NEAR: read byte if VCD_CODETABLE(" + (this.dec_hdr_ind & VCD_CODETABLE) + ")\n"); // DEBUG ONLY
235 | printf("DEC_SAME: read byte if VCD_CODETABLE(" + (this.dec_hdr_ind & VCD_CODETABLE) + ")\n"); // DEBUG ONLY
236 |
237 | if (this.dec_hdr_ind & VCD_CODETABLE) {
238 | throw new Error('VCD_CODETABLE support was removed');
239 | } else {
240 | printf("use the default table.\n"); // DEBUG ONLY
241 | /* Use the default table. */
242 | printf("use default table near_modes " + __rfc3284_code_table_desc.near_modes + "\n"); // DEBUG ONLY
243 | this.acache.s_near = __rfc3284_code_table_desc.near_modes;
244 | printf("use default table same_modes " + __rfc3284_code_table_desc.same_modes + "\n"); // DEBUG ONLY
245 | this.acache.s_same = __rfc3284_code_table_desc.same_modes;
246 | this.code_table = xd3_rfc3284_code_table();
247 | }
248 |
249 | this.xd3_alloc_cache();
250 |
251 | printf("DEC_APPLEN: read size if VCD_APPHEADER(" + (this.dec_hdr_ind & VCD_APPHEADER) // DEBUG ONLY
252 | + ")\n"); // DEBUG ONLY
253 | if (this.dec_hdr_ind & VCD_APPHEADER) {
254 | this.dec_appheadsz = this.getInteger();
255 | printf("dec_appheadsz = " + this.dec_appheadsz + "\n"); // DEBUG ONLY
256 | printf("DEC_APPDAT: \n"); // DEBUG ONLY
257 | // Note: appHeader does not have a 0-termination.
258 | this.dec_apphead = this.xd3_alloc(this.dec_appheadsz + 1);
259 | this.xd3_decode_bytes(this.dec_apphead, 0, this.dec_appheadsz);
260 | this.dec_apphead[this.dec_appheadsz + 1] = 0;
261 | dumpBytes(this.dec_apphead, 0, this.dec_appheadsz + 1); // DEBUG ONLY
262 | }
263 | printf("pos after dec_appheader = " + this.position + "\n\n"); // DEBUG ONLY
264 |
265 | //var targetLength = 0;
266 | while (true) {
267 | printf("DEC_WININD\n"); // DEBUG ONLY
268 | printf("==================================\n"); // DEBUG ONLY
269 | printf(" WINDOW pos = "+this.position+"\n"); // DEBUG ONLY
270 | printf("==================================\n"); // DEBUG ONLY
271 | if (this.position >= this.delta.length) {
272 | break;
273 | }
274 | //targetLength +=
275 | this.handleWindow();
276 | }
277 | printf("no more data\n"); // DEBUG ONLY
278 | return this.dec_buffer.bytes;
279 | };
280 |
281 | _XDelta3Decoder.prototype.xd3_decode_init_window = function() {
282 | this.dec_cpylen = 0;
283 | this.dec_cpyoff = 0;
284 | // this.dec_cksumbytes = 0;
285 |
286 | xd3_init_cache(this.acache);
287 | }
288 |
289 | _XDelta3Decoder.prototype.handleWindow = function() {
290 | this.dec_win_ind = this.delta[this.position++]; // DEC_WININD
291 | printf("dec_win_ind = " + this.dec_win_ind + "(" + toHexStr(this.dec_win_ind) + ")\n"); // DEBUG ONLY
292 | printf("dec_tgtlen = " + this.dec_tgtlen + "(" + toHexStr(this.dec_tgtlen) + ")\n"); // DEBUG ONLY
293 |
294 | if (this.dec_win_ind & ~7) {
295 | throw new Error('VCD_INVWIN unexpected bits set');
296 | }
297 |
298 | printf("window_count = " + this.dec_window_count + "\n"); // DEBUG ONLY
299 | this.current_window = this.dec_window_count;
300 |
301 | this.dec_winstart += this.dec_tgtlen;
302 | printf("dec_winstart = " + this.dec_winstart + "\n"); // DEBUG ONLY
303 |
304 | printf('xd3_decode_init_window\n'); // DEBUG ONLY
305 | this.xd3_decode_init_window();
306 | var SRCORTGT = VCD_SOURCE | VCD_TARGET;
307 | var srcortgt = SRCORTGT & this.dec_win_ind;
308 | printf("srcortgt = " + srcortgt + "\n"); // DEBUG ONLY
309 |
310 | // If using a source or target data segment: read the lenght and position
311 | // integers.
312 | printf("DEC_CPYLEN: dec_cpylen = "+this.dec_cpylen+"\n"); // DEBUG ONLY
313 | printf("DEC_CPYLEN: get size if SRCORTGT("+srcortgt+"), pos = "+this.position+"\n"); // DEBUG ONLY
314 | if (srcortgt) {
315 | this.dec_cpylen = this.getInteger(); // DEC_CPYLEN
316 | printf("dec_cpylen = " + this.dec_cpylen + "\n"); // DEBUG ONLY
317 | }
318 | this.dec_position = this.dec_cpylen;
319 | printf("DEC_CPYOFF: get size if SRCORTGT("+srcortgt+"), pos = "+this.position+"\n"); // DEBUG ONLY
320 | if (srcortgt) {
321 | var sourcePosition = this.getInteger(); // DEC_CPYOFF
322 | this.dec_cpyoff = sourcePosition;
323 | printf("dec_cpyoff = " + this.dec_cpyoff + "\n"); // DEBUG ONLY
324 | }
325 |
326 | this.dec_enclen = this.getInteger(); // DEC_ENCLEN
327 | printf("DEC_ENCLEN: dec_enclen = " + this.dec_enclen + "\n") // DEBUG ONLY
328 |
329 | // Calculate the position if the delta was actually read.
330 | // var positionAfterDelta = this.position + this.dec_enclen;
331 |
332 | // Get the target window length.
333 | this.dec_tgtlen = this.getInteger(); // DEC_TGTLEN
334 | printf("DEC_TGTLEN: dec_tgtlen = " + this.dec_tgtlen + "\n"); // DEBUG ONLY
335 |
336 | this.dec_del_ind = this.getByte(); // DEC_DELIND
337 | printf("DEC_DELIND: dec_del_ind = " + this.dec_del_ind + "\n"); // DEBUG ONLY
338 |
339 | this.data_sect.size = this.getInteger(); // DEC_DATALEN
340 | this.inst_sect.size = this.getInteger(); // DEC_INSTLEN
341 | this.addr_sect.size = this.getInteger(); // DEC_ADDRLEN
342 | printf("DEC_DATALEN: data_sect size = " + this.data_sect.size + "\n"); // DEBUG ONLY
343 | printf("DEC_INSTLEN: inst_sect size = " + this.inst_sect.size + "\n"); // DEBUG ONLY
344 | printf("DEC_ADDRLEN: addr_sect size = " + this.addr_sect.size + "\n"); // DEBUG ONLY
345 |
346 | printf("DEC_CKSUM: get checksum if VCD_ADLER32 pos = " + this.position + "\n"); // DEBUG ONLY
347 | if (this.dec_win_ind & VCD_ADLER32) { // DEC_CKSUM
348 | this.dec_cksum = this.xd3_decode_allocate(4);
349 | dumpBytes(this.dec_cksum, 0, 4); // DEBUG ONLY
350 | for (var i = 0; i < 4; i += 1) {
351 | this.dec_adler32 = (this.dec_adler32 << 8) | this.dec_cksum[i];
352 | }
353 | printf("stream->dec_adler32 = "+this.dec_adler32+"\n"); // DEBUG ONLY
354 | }
355 |
356 | this.xd3_decode_sections();
357 | dumpBytes(this.data_sect.bytes, 0, this.data_sect.size); // DEBUG ONLY
358 | dumpBytes(this.inst_sect.bytes, 0, this.inst_sect.size); // DEBUG ONLY
359 | dumpBytes(this.addr_sect.bytes, 0, this.addr_sect.size); // DEBUG ONLY
360 |
361 | printf('DEC_EMIT:\n'); // DEBUG ONLY
362 | /* In the C++ code:
363 | * To speed VCD_SOURCE block-address calculations, the source
364 | * cpyoff_blocks and cpyoff_blkoff are pre-computed.
365 | * However, in this Javascript code there is no 'blocks'.
366 | */
367 | if (this.dec_win_ind & VCD_SOURCE) {
368 | printf("stream->dec_cpyoff = " + this.dec_cpyoff + "\n"); // DEBUG ONLY
369 | this.src.cpyoff_blkoff = this.dec_cpyoff;
370 | printf("src->cpyoff_blkoff = " + this.src.cpyoff_blkoff + "\n"); // DEBUG ONLY
371 | }
372 | this.xd3_decode_emit();
373 |
374 | return this.dec_tgtlen;
375 | };
376 |
377 | /**
378 | * This function only has code if the preprocessor statement
379 | * "#if SECONDARY_ANY" is set. SECONDARY_ANY does not seem to be set.
380 | */
381 | _XDelta3Decoder.prototype.xd3_decode_secondary_sections = function() { //
382 | };
383 |
384 | /**
385 | * @param {!xd3_desect} sect
386 | */
387 | _XDelta3Decoder.prototype.xd3_decode_section = function(sect) {
388 | // It is possible to just point into the buffer but perhaps that can be done
389 | // later.
390 | sect.bytes = this.xd3_decode_allocate(sect.size);
391 | };
392 |
393 | _XDelta3Decoder.prototype.xd3_decode_sections = function() {
394 | printf("xd3_decode_sections\n"); // DEBUG ONLY
395 | this.xd3_decode_section(this.data_sect);
396 | this.xd3_decode_section(this.inst_sect);
397 | this.xd3_decode_section(this.addr_sect);
398 |
399 | this.xd3_decode_secondary_sections();
400 |
401 | this.xd3_decode_setup_buffers();
402 | };
403 |
404 | _XDelta3Decoder.prototype.xd3_decode_setup_buffers = function() {
405 | printf("xd3_decode_setup_buffers\n"); // DEBUG ONLY
406 | this.dec_buffer = new DataObject(new Uint8Array(this.dec_tgtlen));
407 | };
408 |
409 | var VCD_SELF = 0;
410 | var VCD_HERE = 1;
411 |
412 | /**
413 | * xd3_decode_address
414 | * @param {number} here
415 | * @param {number} mode
416 | * @param {!xd3_desect} sect
417 | */
418 | _XDelta3Decoder.prototype.xd3_decode_address = function(here, mode, sect) {
419 | printf("xd3_decode_address\n"); // DEBUG ONLY
420 | var val;
421 | var same_start = 2 + this.acache.s_near;
422 | printf("here = " + here + "\n"); // DEBUG ONLY
423 | printf("mode = " + mode + "\n"); // DEBUG ONLY
424 | printf("acache.s_near = " + this.acache.s_near + "\n"); // DEBUG ONLY
425 | printf("same_start = " + same_start + "\n"); // DEBUG ONLY
426 |
427 | if (mode < same_start) {
428 | val = sect.getInteger();
429 | printf("val = " + val + "\n"); // DEBUG ONLY
430 | switch (mode) {
431 | case VCD_SELF:
432 | printf('use self\n'); // DEBUG ONLY
433 | break;
434 | case VCD_HERE:
435 | printf('subtract from here\n'); // DEBUG ONLY
436 | // var old_val = val;
437 | val = here - val;
438 | printf("val = " + val + "\n"); // DEBUG ONLY
439 | break;
440 | default:
441 | printf('add near_array['+(mode-2)+'] = '+ // DEBUG ONLY
442 | this.acache.near_array[mode - 2]+'\n'); // DEBUG ONLY
443 | val += this.acache.near_array[mode - 2];
444 | printf("val = " + val + "\n"); // DEBUG ONLY
445 | }
446 | } else {
447 | mode -= same_start;
448 | var offset = sect.getByte();
449 | printf("mode = "+mode+", offset = "+offset+"\n"); // DEBUG ONLY
450 | val = this.acache.same_array[mode * 256 + offset];
451 | printf("val = " + val + "\n"); // DEBUG ONLY
452 | }
453 |
454 | this.xd3_update_cache(this.acache, val);
455 |
456 | return val;
457 | };
458 |
459 | /**
460 | * @param {!xd3_addr_cache} acache
461 | * @param {number} addr
462 | */
463 | _XDelta3Decoder.prototype.xd3_update_cache = function(acache, addr) {
464 | printf("acache->s_near = "+acache.s_near+"\n"); // DEBUG ONLY
465 | if (acache.s_near > 0) {
466 | acache.near_array[acache.next_slot] = addr;
467 | printf("acache->near_array["+acache.next_slot+"] = "+addr+"\n"); // DEBUG ONLY
468 | acache.next_slot = (acache.next_slot + 1) % acache.s_near;
469 | printf("acache->next_slot = "+acache.next_slot+"\n"); // DEBUG ONLY
470 | }
471 |
472 | printf("acache->s_same = "+acache.s_same+"\n"); // DEBUG ONLY
473 | if (acache.s_same > 0) {
474 | acache.same_array[addr % (acache.s_same * 256)] = addr;
475 | printf("acache->same_array["+(addr % (acache.s_same*256))+"] = "+addr+"\n"); // DEBUG ONLY
476 | }
477 | };
478 |
479 | /**
480 | * @param {!xd3_hinst} inst
481 | */
482 | _XDelta3Decoder.prototype.xd3_decode_output_halfinst = function(inst) {
483 | printf("xd3_decode_output_halfinst: type=" + inst.type + // DEBUG ONLY
484 | ", addr=" + inst.addr + ", size=" + inst.size + "\n"); // DEBUG ONLY
485 | var take = inst.size;
486 | var blkoff;
487 | var start_pos = this.dec_buffer.pos; // DEBUG ONLY
488 | printf("start_pos = " + start_pos + "\n"); // DEBUG ONLY
489 |
490 | switch (inst.type) {
491 | case XD3_RUN:
492 | var val = this.data_sect.getByte();
493 | printf(" >>>> XD3_RUN: memset "+ toHexStr(val) +" for " + take + "\n"); // DEBUG ONLY
494 | this.dec_buffer.fill(val, take);
495 | dumpBytes(this.dec_buffer.bytes, start_pos, take); // DEBUG ONLY
496 | break;
497 |
498 | case XD3_ADD:
499 | printf(" >>>> XD3_ADD: memcpy "+take+" from the data_sect\n"); // DEBUG ONLY
500 | this.dec_buffer.copySect(this.data_sect, take);
501 | dumpBytes(this.dec_buffer.bytes, start_pos, take); // DEBUG ONLY
502 | break;
503 |
504 | default:
505 | printf(" >>>> XD3_CPY\n"); // DEBUG ONLY
506 | printf("dec_cpylen = " + this.dec_cpylen + "\n"); // DEBUG ONLY
507 | var overlap;
508 | var overlap_pos;
509 | if (inst.addr < this.dec_cpylen) {
510 | overlap = 0;
511 | printf("overlap = 0\n"); // DEBUG ONLY
512 | if (this.dec_win_ind & VCD_TARGET) {
513 | throw new Error('VCD_TARGET not supported');
514 | } else {
515 | printf("read source block\n"); // DEBUG ONLY
516 | blkoff = this.src.cpyoff_blkoff;
517 | printf("blkoff = " + blkoff + "\n"); // DEBUG ONLY
518 | printf("add inst addr to blkoff\n"); // DEBUG ONLY
519 | blkoff = this.dec_cpyoff + inst.addr;
520 | printf("blkoff = " + blkoff + "\n"); // DEBUG ONLY
521 | }
522 | } else {
523 | overlap = 1;
524 | printf("overlap = 1\n"); // DEBUG ONLY
525 | overlap_pos = inst.addr - this.dec_cpylen;
526 | printf("overlap_pos = "+overlap_pos+"\n"); // DEBUG ONLY
527 | }
528 | if (overlap) {
529 | printf(" <<<< manually copy "+take+"\n"); // DEBUG ONLY
530 | this.dec_buffer.copyBytes(this.dec_buffer.bytes, overlap_pos, take);
531 | dumpBytes(this.dec_buffer.bytes, start_pos, take); // DEBUG ONLY
532 | } else {
533 | printf(" <<<< memcopy take=" + take + "\n"); // DEBUG ONLY
534 | this.dec_buffer.copyBytes(this.source.bytes, blkoff, take);
535 | dumpBytes(this.dec_buffer.bytes, start_pos, take); // DEBUG ONLY
536 | }
537 | }
538 | };
539 |
540 | /**
541 | * xref: xd3_decode_parse_halfinst
542 | * @param {!xd3_hinst} inst
543 | */
544 | _XDelta3Decoder.prototype.xd3_decode_parse_halfinst = function(inst) {
545 | printf("xd3_decode_parse_halfinst\n"); // DEBUG ONLY
546 | // Get size and address if necessary.
547 | if (inst.size == 0) {
548 | inst.size = this.inst_sect.getInteger();
549 | printf("read inst size = " + inst.size + "\n"); // DEBUG ONLY
550 | }
551 |
552 | /* For copy instructions, read address. */
553 | if (inst.type >= XD3_CPY) {
554 | printf("dec_position = " + this.dec_position + "\n"); // DEBUG ONLY
555 | var mode = inst.type - XD3_CPY;
556 | printf("mode = " + mode + "\n"); // DEBUG ONLY
557 | inst.addr =
558 | this.xd3_decode_address(this.dec_position, mode, this.addr_sect);
559 | printf("XD3_CPY address = " + inst.addr + "\n"); // DEBUG ONLY
560 | }
561 |
562 | printf('dec_position = ' + this.dec_position + "\n"); // DEBUG ONLY
563 | printf('inst size = ' + inst.size + "\n"); // DEBUG ONLY
564 | this.dec_position += inst.size;
565 | printf('dec_position = ' + this.dec_position + "\n"); // DEBUG ONLY
566 | };
567 |
568 | var instCount = 0; // DEBUG ONLY
569 | /**
570 | * xref: xd3_decode_instruction
571 | */
572 | _XDelta3Decoder.prototype.xd3_decode_instruction = function() {
573 | printf("xd3_decode_instruction "+(instCount++)+"\n"); // DEBUG ONLY
574 | var code_table = this.code_table;
575 | var instPair = this.inst_sect.getByte();
576 | printf('instPair = ' + instPair + "\n"); // DEBUG ONLY
577 |
578 | this.dec_current1.type = code_table.tableRows[instPair].type1;
579 | this.dec_current1.size = code_table.tableRows[instPair].size1;
580 | // dec_current1.addr keeps it previous value.
581 |
582 | this.dec_current2.type = code_table.tableRows[instPair].type2;
583 | this.dec_current2.size = code_table.tableRows[instPair].size2;
584 | // dec_current2.addr keeps it previous value.
585 |
586 | printInstructionPair(this.dec_current1, this.dec_current2); // DEBUG ONLY
587 |
588 | /* For each instruction with a real operation, decode the
589 | * corresponding size and addresses if necessary. Assume a
590 | * code-table may have NOOP in either position, although this is
591 | * unlikely. */
592 | if (this.dec_current1.type != XD3_NOOP) {
593 | this.xd3_decode_parse_halfinst(this.dec_current1);
594 | }
595 | if (this.dec_current2.type != XD3_NOOP) {
596 | this.xd3_decode_parse_halfinst(this.dec_current2);
597 | }
598 | };
599 |
600 | _XDelta3Decoder.prototype.xd3_decode_finish_window = function() {
601 | printf("xd3_decode_finish_window\n"); // DEBUG ONLY
602 | // stream->dec_winbytes = 0;
603 | // stream->dec_state = DEC_FINISH;
604 | this.data_sect.pos = 0;
605 | this.inst_sect.pos = 0;
606 | this.addr_sect.pos = 0;
607 | };
608 |
609 | _XDelta3Decoder.prototype.xd3_decode_emit = function() {
610 | printf("\n\n"); // DEBUG ONLY
611 | printf("#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@\n"); // DEBUG ONLY
612 | printf(" xd3_decode_emit:\n"); // DEBUG ONLY
613 | printf("#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@#@\n"); // DEBUG ONLY
614 |
615 | var instLength = this.inst_sect.bytes.byteLength;
616 | /* Decode next instruction pair. */
617 | while (this.inst_sect.pos < instLength) {
618 | printf('\n========== Decode next instruction pair ==========\n'); // DEBUG ONLY
619 | this.xd3_decode_instruction();
620 |
621 | /* Output dec_current1 */
622 | if (this.dec_current1.type != XD3_NOOP) {
623 | printf("output dec_current1 ----------\n"); // DEBUG ONLY
624 | this.xd3_decode_output_halfinst(this.dec_current1);
625 | }
626 | /* Output dec_current2 */
627 | if (this.dec_current2.type != XD3_NOOP) {
628 | printf("output dec_current2 ----------\n"); // DEBUG ONLY
629 | this.xd3_decode_output_halfinst(this.dec_current2);
630 | }
631 | }
632 | printf("check checksum is VCD_ADLER32 set\n"); // DEBUG ONLY
633 | if (this.dec_win_ind & VCD_ADLER32) {
634 | var a32 = adler32(1, this.dec_buffer.bytes, 0, this.dec_tgtlen);
635 | printf("a32 = "+a32+"\n"); // DEBUG ONLY
636 | if (a32 != this.dec_adler32) {
637 | throw new Error('target window checksum mismatch');
638 | }
639 | }
640 |
641 | /* Finished with a window. */
642 | this.xd3_decode_finish_window();
643 | };
644 |
645 | _XDelta3Decoder.prototype.xd3_alloc = function(length) {
646 | return new Uint8Array(length);
647 | };
648 |
649 | _XDelta3Decoder.prototype.xd3_decode_bytes = function(bytes, pos, length) {
650 | for (var i = 0; i < length; i++) {
651 | bytes[pos + i] = this.delta[this.position++];
652 | }
653 | };
654 |
655 | _XDelta3Decoder.prototype.xd3_decode_allocate = function(length) {
656 | var bytes =
657 | new Uint8Array(this.delta.slice(this.position, this.position + length));
658 | this.position += length;
659 | return bytes;
660 | };
661 |
662 | _XDelta3Decoder.prototype.getByte = function() {
663 | return this.delta[this.position++];
664 | };
665 |
666 | _XDelta3Decoder.prototype.getInteger = function() {
667 | var maxBytes = Math.min(20, this.delta.length - this.position);
668 | var integer = 0;
669 | for (var i = 0; i < maxBytes; i++) {
670 | var aPart = this.delta[this.position++];
671 | integer += aPart & 0x7F;
672 | if (!(aPart & 0x80)) {
673 | return integer;
674 | }
675 | integer <<= 7;
676 | }
677 | throw new Error('delta integer too long');
678 | };
679 |
680 | /**
681 | * The code table.
682 | * @param {!Array} tableRows
683 | * @constructor
684 | * @struct
685 | */
686 | var xd3_dinst_table = function(tableRows) {
687 | /** @type {!Array} */
688 | this.tableRows = tableRows;
689 | };
690 |
691 | /**
692 | * xd3_hinst
693 | * @constructor
694 | */
695 | function xd3_hinst() {
696 | this.type = XD3_NOOP;
697 | this.size = 0;
698 | this.addr = 0;
699 | }
700 |
701 | /**
702 | * The code-table double instruction.
703 | * @constructor
704 | */
705 | function xd3_dinst() {
706 | /** @type {number} */
707 | this.type1 = XD3_NOOP;
708 | /** @type {number} */
709 | this.size1 = 0;
710 | /** @type {number} */
711 | this.type2 = XD3_NOOP;
712 | /** @type {number} */
713 | this.size2 = 0;
714 | }
715 |
716 | /**
717 | * @param {!xd3_code_table_desc} desc
718 | * @return {!xd3_dinst_table}
719 | */
720 | function xd3_build_code_table(desc) {
721 | printf("xd3_build_code_table\n"); // DEBUG ONLY
722 | var startRow = 0; // DEBUG ONLY
723 | var row = 0;
724 | var tableRows = new Array(256);
725 | for (var i = 0; i < 256; i++) {
726 | tableRows[i] = new xd3_dinst();
727 | }
728 | var cpyModes = 2 + desc.near_modes + desc.same_modes;
729 |
730 | // The single RUN command.
731 | tableRows[row++].type1 = XD3_RUN;
732 |
733 | // The ADD only commands.
734 | tableRows[row++].type1 = XD3_ADD;
735 | for (var size1 = 1; size1 <= desc.add_sizes; size1++) {
736 | tableRows[row].type1 = XD3_ADD;
737 | tableRows[row++].size1 = size1;
738 | }
739 | dumpCodeTableRows(tableRows, startRow, row); // DEBUG ONLY
740 | startRow = row; // DEBUG ONLY
741 |
742 | // The Copy only commands.
743 | for (var mode = 0; mode < cpyModes; mode++) {
744 | tableRows[row++].type1 = XD3_CPY + mode;
745 |
746 | for (var size1 = MIN_MATCH; size1 < MIN_MATCH + desc.cpy_sizes; size1++) {
747 | tableRows[row].type1 = XD3_CPY + mode;
748 | tableRows[row++].size1 = size1;
749 | }
750 | dumpCodeTableRows(tableRows, startRow, row); // DEBUG ONLY
751 | startRow = row; // DEBUG ONLY
752 | }
753 |
754 | // The Add/Copy commands.
755 | for (var mode = 0; mode < cpyModes; mode++) {
756 | for (var size1 = 1; size1 <= desc.addcopy_add_max; size1++) {
757 | var max = (mode < 2 + desc.near_modes) ? //
758 | desc.addcopy_near_cpy_max :
759 | desc.addcopy_same_cpy_max;
760 | for (var size2 = MIN_MATCH; size2 <= max; size2++) {
761 | tableRows[row].type1 = XD3_ADD;
762 | tableRows[row].size1 = size1;
763 | tableRows[row].type2 = XD3_CPY + mode;
764 | tableRows[row++].size2 = size2;
765 | }
766 | }
767 | dumpCodeTableRows(tableRows, startRow, row); // DEBUG ONLY
768 | startRow = row; // DEBUG ONLY
769 | }
770 |
771 | // The Copy/Add commands.
772 | for (var mode = 0; mode < cpyModes; mode++) {
773 | var max = (mode < 2 + desc.near_modes) ? //
774 | desc.copyadd_near_cpy_max :
775 | desc.copyadd_same_cpy_max;
776 | for (var size1 = MIN_MATCH; size1 <= max; size1++) {
777 | for (var size2 = 1; size2 <= desc.copyadd_add_max; size2++) {
778 | tableRows[row].type1 = XD3_CPY + mode;
779 | tableRows[row].size1 = size1;
780 | tableRows[row].type2 = XD3_ADD;
781 | tableRows[row++].size2 = size2;
782 | }
783 | }
784 | }
785 | dumpCodeTableRows(tableRows, startRow, row); // DEBUG ONLY
786 |
787 | return new xd3_dinst_table(tableRows);
788 | }
789 |
790 |
791 | /**
792 | * @constructor
793 | */
794 | function xd3_code_table_desc() {
795 | this.add_sizes = 0;
796 | this.near_modes = 0;
797 | this.same_modes = 0;
798 | this.cpy_sizes = 0;
799 |
800 | this.addcopy_add_max = 0;
801 | this.addcopy_near_cpy_max = 0;
802 | this.addcopy_same_cpy_max = 0;
803 |
804 | this.copyadd_add_max = 0;
805 | this.copyadd_near_cpy_max = 0;
806 | this.copyadd_same_cpy_max = 0;
807 | }
808 |
809 |
810 | /**
811 | * This builds the __rfc3284_code_table_desc
812 | * Assumes a single RUN instruction
813 | * Assumes that MIN_MATCH is 4.
814 | * @return {!xd3_code_table_desc}
815 | */
816 | function build_rfc3284_code_table_desc() {
817 | var desc = new xd3_code_table_desc();
818 | desc.add_sizes = 17;
819 | desc.near_modes = 4;
820 | desc.same_modes = 3;
821 | desc.cpy_sizes = 15;
822 |
823 | desc.addcopy_add_max = 4;
824 | desc.addcopy_near_cpy_max = 6;
825 | desc.addcopy_same_cpy_max = 4;
826 |
827 | desc.copyadd_add_max = 1;
828 | desc.copyadd_near_cpy_max = 4;
829 | desc.copyadd_same_cpy_max = 4;
830 |
831 | // xd3_code_table_sizes addcopy_max_sizes[MAX_MODES];
832 | // { {6,163,3},{6,175,3},{6,187,3},{6,199,3},{6,211,3},{6,223,3},
833 | // {4,235,1},{4,239,1},{4,243,1} },
834 |
835 | // xd3_code_table_sizes copyadd_max_sizes[MAX_MODES];
836 | // { {4,247,1},{4,248,1},{4,249,1},{4,250,1},{4,251,1},{4,252,1},
837 | // {4,253,1},{4,254,1},{4,255,1} },
838 |
839 | return desc;
840 | }
841 |
842 | var __rfc3284_code_table_desc = build_rfc3284_code_table_desc();
843 |
844 | var A32_BASE = 65521; /* Largest prime smaller than 2^16 */
845 | var A32_NMAX = 5552; /* NMAX is the largest n such that 255n(n+1)/2
846 | + (n+1)(BASE-1) <= 2^32-1 */
847 |
848 | // 1140 #define A32_DO1(buf,i) {s1 += buf[i]; s2 += s1;}
849 | // 1141 #define A32_DO2(buf,i) A32_DO1(buf,i); A32_DO1(buf,i+1);
850 | // 1142 #define A32_DO4(buf,i) A32_DO2(buf,i); A32_DO2(buf,i+2);
851 | // 1143 #define A32_DO8(buf,i) A32_DO4(buf,i); A32_DO4(buf,i+4);
852 | // 1144 #define A32_DO16(buf) A32_DO8(buf,0); A32_DO8(buf,8);
853 |
854 |
855 | /**
856 | * Calculated the Adler32 checksum.
857 | * @param {number} adler I'm not sure what this is.
858 | * @param {!Uint8Array} buf
859 | * @param {number} pos
860 | * @param {number} len
861 | * @return {number}
862 | */
863 | function adler32(adler, buf, pos, len) {
864 | printf("adler32: adler = "+adler+"\n"); // DEBUG ONLY
865 | printf("adler32: len = "+len+"\n"); // DEBUG ONLY
866 | var s1 = adler & 0xffff;
867 | var s2 = (adler >> 16) & 0xffff;
868 | var k;
869 |
870 | while (len > 0) {
871 | k = (len < A32_NMAX) ? len : A32_NMAX;
872 | len -= k;
873 |
874 | if (k != 0) {
875 | do {
876 | s1 += buf[pos++];
877 | s2 += s1;
878 | } while (--k);
879 | }
880 |
881 | s1 %= A32_BASE;
882 | s2 %= A32_BASE;
883 | }
884 |
885 | return (s2 << 16) | s1;
886 | }
887 |
888 |
889 | /**
890 | * @constructor
891 | */
892 | function xd3_addr_cache(s_near, s_same) {
893 | this.s_near = s_near;
894 | this.s_same = s_same;
895 | this.next_slot = 0; /* the circular index for near */
896 | this.near_array = null; /* array of size s_near */
897 | this.same_array = null; /* array of size s_same*256 */
898 | }
899 |
900 |
901 | /**
902 | * @param {!xd3_addr_cache} acache
903 | */
904 | function xd3_init_cache(acache) {
905 | printf("xd3_init_cache\n"); // DEBUG ONLY
906 | if (acache.s_near > 0) {
907 | for (var i = 0; i < acache.near_array.length; i++) {
908 | acache.near_array[i] = 0;
909 | }
910 | acache.next_slot = 0;
911 | }
912 |
913 | if (acache.s_same > 0) {
914 | for (var i = 0; i < acache.same_array.length; i++) {
915 | acache.same_array[i] = 0;
916 | }
917 | }
918 | }
919 |
920 | /**
921 | * Used by the decoder to buffer input in sections.
922 | * XDelta3 C++ struct.
923 | * @constructor
924 | * @struct
925 | */
926 | function xd3_desect() {
927 | /**
928 | * The buffer as a slice of the backingBuffer;
929 | * @type {?Uint8Array}
930 | */
931 | this.bytes = null;
932 |
933 | /** @type {number} */
934 | this.size = 0;
935 |
936 | /** @type {number} */
937 | this.pos = 0;
938 | }
939 |
940 | /**
941 | * Gets a byte from the section.
942 | * @return {number}
943 | */
944 | xd3_desect.prototype.getByte = function() {
945 | if (!this.bytes) {
946 | throw new Error('bytes not set');
947 | }
948 | return this.bytes[this.pos++];
949 | };
950 |
951 | /**
952 | * Gets an integer from the section.
953 | * XDelta3 integers are encodes as a variable number of 7 bit bytes. Bit 8, the
954 | * most significant bit is used to indicate more bytes needed.
955 | * @return {number}
956 | */
957 | xd3_desect.prototype.getInteger = function() {
958 | if (!this.bytes) {
959 | throw new Error('bytes not set');
960 | }
961 | var val = 0;
962 | for (var i = 0; i < 10; i++) {
963 | var aByte = this.bytes[this.pos++];
964 | val += aByte & 0x7F;
965 | if (!(aByte & 0x80)) {
966 | return val;
967 | }
968 | val <<= 7;
969 | }
970 | throw new Error('invalid number');
971 | };
972 |
973 |
974 | /**
975 | * Builds a default code table.
976 | * @return {!xd3_dinst_table}
977 | */
978 | function xd3_rfc3284_code_table() {
979 | printf("xd3_rfc3284_code_table\n"); // DEBUG ONLY
980 | return xd3_build_code_table(__rfc3284_code_table_desc);
981 | }
982 |
983 | /**
984 | * Allocates and initializes a Javascript Array.
985 | * @return {!Array}
986 | */
987 | function allocArray(len, val) {
988 | var arr = new Array(len);
989 | for (var i = 0; i < len; i++) {
990 | arr[i] = val;
991 | }
992 | return arr;
993 | }
994 |
995 | /**
996 | * @constructor
997 | */
998 | function xd3_source() {
999 | /** @type {number} */
1000 | this.cpyoff_blkoff = -1;
1001 | }
1002 |
1003 | /**
1004 | * @param {!Uint8Array} bytes
1005 | * @constructor
1006 | */
1007 | function DataObject(bytes) {
1008 | this.pos = 0;
1009 | this.bytes = bytes;
1010 | };
1011 |
1012 | DataObject.prototype.getByte = function() {
1013 | return this.bytes[this.pos++];
1014 | };
1015 |
1016 | DataObject.prototype.getInteger = function() {
1017 | var val = 0;
1018 | for (var i = 0; i < 10; i++) {
1019 | var aByte = this.bytes[this.pos++];
1020 | val += aByte & 0x7F;
1021 | if (!(aByte & 0x80)) {
1022 | return val;
1023 | }
1024 | val <<= 7;
1025 | }
1026 | throw new Error('invalid number');
1027 | };
1028 |
1029 | DataObject.prototype.fill = function(val, length) {
1030 | // TODO(bstell): see if there is a function for this.
1031 | for (var i = 0; i < length; i++) {
1032 | this.bytes[this.pos++] = val;
1033 | }
1034 | };
1035 |
1036 | /**
1037 | * @param {!xd3_desect} sect
1038 | * @param {number} length
1039 | */
1040 | DataObject.prototype.copySect = function(sect, length) {
1041 | // TODO(bstell): see if there is a function for this.
1042 | for (var i = 0; i < length; i++) {
1043 | this.bytes[this.pos++] = sect.bytes[sect.pos++];
1044 | }
1045 | };
1046 |
1047 | DataObject.prototype.copyBytes = function(bytes, offset, length) {
1048 | // TODO(bstell): see if there is a function for this.
1049 | for (var i = 0; i < length; i++) {
1050 | this.bytes[this.pos++] = bytes[offset++];
1051 | }
1052 | };
1053 |
1054 | })();
1055 |
--------------------------------------------------------------------------------