Perliminar Support for iPad

webserver/dataview.js

@@ -0,0 +1,322 @@
+//
+// jDataView by Vjeux - Jan 2010
+//
+// A unique way to read a binary file in the browser
+// http://github.com/vjeux/jsDataView
+// http://blog.vjeux.com/ <vjeuxx@gmail.com>
+// 
+
+
+(function () {
+
+var compatibility = {
+	ArrayBuffer: typeof ArrayBuffer !== 'undefined',
+	DataView: typeof DataView !== 'undefined' && 'getFloat64' in DataView.prototype
+}
+
+var jDataView = function (buffer, byteOffset, byteLength, littleEndian) {
+	this._buffer = buffer;
+
+	// Handle Type Errors
+	if (!(compatibility.ArrayBuffer && buffer instanceof ArrayBuffer) &&
+		!(typeof buffer === 'string')) {
+		throw new TypeError("Type error");
+	}
+
+	// Check parameters and existing functionnalities
+	this._isArrayBuffer = compatibility.ArrayBuffer && buffer instanceof ArrayBuffer;
+	this._isDataView = compatibility.DataView && this._isArrayBuffer;
+
+	// Default Values
+	this._littleEndian = littleEndian === undefined ? false : littleEndian;
+
+	var bufferLength = this._isArrayBuffer ? buffer.byteLength : buffer.length;
+	if (byteOffset == undefined) {
+		byteOffset = 0;
+	}
+
+	if (byteLength == undefined) {
+		byteLength = bufferLength - byteOffset;
+	}
+
+	if (!this._isDataView) {
+		// Do additional checks to simulate DataView
+		if (typeof byteOffset !== 'number') {
+			throw new TypeError("Type error");
+		}
+		if (typeof byteLength !== 'number') {
+			throw new TypeError("Type error");
+		}
+		if (typeof byteOffset < 0) {
+			throw new Error("INDEX_SIZE_ERR: DOM Exception 1");
+		}
+		if (typeof byteLength < 0) {
+			throw new Error("INDEX_SIZE_ERR: DOM Exception 1");
+		}
+	}
+
+	// Instanciate
+	if (this._isDataView) {
+		this._view = new DataView(buffer, byteOffset, byteLength);
+		this._start = 0;
+	}
+	this._start = byteOffset;
+	if (this._end >= bufferLength) {
+		throw new Error("INDEX_SIZE_ERR: DOM Exception 1");
+	}
+
+	this._offset = 0;
+	this.length = byteLength;
+};
+
+jDataView.createBuffer = function () {
+	if (typeof ArrayBuffer !== 'undefined') {
+		var buffer = new ArrayBuffer(arguments.length);
+		var view = new Int8Array(buffer);
+		for (var i = 0; i < arguments.length; ++i) {
+			view[i] = arguments[i];
+		}
+		return buffer;
+	}
+
+	return String.fromCharCode.apply(null, arguments);
+};
+
+jDataView.prototype = {
+
+	// Helpers
+
+	getString: function (length, byteOffset) {
+		var value;
+
+		// Handle the lack of byteOffset
+		if (byteOffset === undefined) {
+			var byteOffset = this._offset;
+		}
+
+		// Error Checking
+		if (typeof byteOffset !== 'number') {
+			throw new TypeError("Type error");
+		}
+		if (length < 0 || byteOffset + length > this.length) {
+			throw new Error("INDEX_SIZE_ERR: DOM Exception 1");
+		}
+
+		if (this._isArrayBuffer) {
+			// Use Int8Array and String.fromCharCode to extract a string
+			var int8array = new Int8Array(this._buffer, this._start + byteOffset, length);
+			var stringarray = [];
+			for (var i = 0; i < length; ++i) {
+				stringarray[i] = int8array[i];
+			}
+			value = String.fromCharCode.apply(null, stringarray);
+		} else {
+			value = this._buffer.substr(this._start + byteOffset, length);
+		}
+
+		this._offset = byteOffset + length;
+		return value;
+	},
+
+	getChar: function (byteOffset) {
+		var value, size = 1;
+
+		// Handle the lack of byteOffset
+		if (byteOffset === undefined) {
+			var byteOffset = this._offset;
+		}
+
+		if (this._isArrayBuffer) {
+			// Use Int8Array and String.fromCharCode to extract a string
+			value = String.fromCharCode(this.getUint8(byteOffset));
+		} else {
+			// Error Checking
+			if (typeof byteOffset !== 'number') {
+				throw new TypeError("Type error");
+			}
+			if (length < 0 || byteOffset + size > this.length) {
+				throw new Error("INDEX_SIZE_ERR: DOM Exception 1");
+			}
+
+			value = this._buffer.charAt(this._start + byteOffset);
+			this._offset = byteOffset + size;
+		}
+
+		return value;
+	},
+
+	tell: function () {
+		return this._offset;
+	},
+
+	seek: function (byteOffset) {
+		if (typeof byteOffset !== 'number') {
+			throw new TypeError("Type error");
+		}
+		if (byteOffset < 0 || byteOffset > this.length) {
+			throw new Error("INDEX_SIZE_ERR: DOM Exception 1");
+		}
+
+		this._offset = byteOffset;
+	},
+
+	// Compatibility functions on a String Buffer
+
+	_endianness: function (offset, pos, max, littleEndian) {
+		return offset + (littleEndian ? max - pos - 1 : pos);
+	},
+
+	_getFloat64: function (offset, littleEndian) {
+		var b0 = this._getUint8(this._endianness(offset, 0, 8, littleEndian)),
+			b1 = this._getUint8(this._endianness(offset, 1, 8, littleEndian)),
+			b2 = this._getUint8(this._endianness(offset, 2, 8, littleEndian)),
+			b3 = this._getUint8(this._endianness(offset, 3, 8, littleEndian)),
+			b4 = this._getUint8(this._endianness(offset, 4, 8, littleEndian)),
+			b5 = this._getUint8(this._endianness(offset, 5, 8, littleEndian)),
+			b6 = this._getUint8(this._endianness(offset, 6, 8, littleEndian)),
+			b7 = this._getUint8(this._endianness(offset, 7, 8, littleEndian)),
+
+			sign = 1 - (2 * (b0 >> 7)),
+			exponent = ((((b0 << 1) & 0xff) << 3) | (b1 >> 4)) - (Math.pow(2, 10) - 1),
+
+		// Binary operators such as | and << operate on 32 bit values, using + and Math.pow(2) instead
+			mantissa = ((b1 & 0x0f) * Math.pow(2, 48)) + (b2 * Math.pow(2, 40)) + (b3 * Math.pow(2, 32))
+					+ (b4 * Math.pow(2, 24)) + (b5 * Math.pow(2, 16)) + (b6 * Math.pow(2, 8)) + b7;
+
+		if (mantissa == 0 && exponent == -(Math.pow(2, 10) - 1)) {
+			return 0.0;
+		}
+
+		if (exponent == -1023) { // Denormalized
+			return sign * mantissa * Math.pow(2, -1022 - 52);
+		}
+
+		return sign * (1 + mantissa * Math.pow(2, -52)) * Math.pow(2, exponent);
+	},
+
+	_getFloat32: function (offset, littleEndian) {
+		var b0 = this._getUint8(this._endianness(offset, 0, 4, littleEndian)),
+			b1 = this._getUint8(this._endianness(offset, 1, 4, littleEndian)),
+			b2 = this._getUint8(this._endianness(offset, 2, 4, littleEndian)),
+			b3 = this._getUint8(this._endianness(offset, 3, 4, littleEndian)),
+
+			sign = 1 - (2 * (b0 >> 7)),
+			exponent = (((b0 << 1) & 0xff) | (b1 >> 7)) - 127,
+			mantissa = ((b1 & 0x7f) << 16) | (b2 << 8) | b3;
+
+		if (mantissa == 0 && exponent == -127) {
+			return 0.0;
+		}
+
+		if (exponent == -127) { // Denormalized
+			return sign * mantissa * Math.pow(2, -126 - 23);
+		}
+
+		return sign * (1 + mantissa * Math.pow(2, -23)) * Math.pow(2, exponent);
+	},
+
+	_getInt32: function (offset, littleEndian) {
+		var b = this._getUint32(offset, littleEndian);
+		return b > Math.pow(2, 31) - 1 ? b - Math.pow(2, 32) : b;
+	},
+
+	_getUint32: function (offset, littleEndian) {
+		var b3 = this._getUint8(this._endianness(offset, 0, 4, littleEndian)),
+			b2 = this._getUint8(this._endianness(offset, 1, 4, littleEndian)),
+			b1 = this._getUint8(this._endianness(offset, 2, 4, littleEndian)),
+			b0 = this._getUint8(this._endianness(offset, 3, 4, littleEndian));
+
+		return (b3 * Math.pow(2, 24)) + (b2 << 16) + (b1 << 8) + b0;
+	},
+
+	_getInt16: function (offset) {
+		var b = this._getUint16(offset);
+		return b > Math.pow(2, 15) - 1 ? b - Math.pow(2, 16) : b;
+	},
+
+	_getUint16: function (offset, littleEndian) {
+		var b1 = this._getUint8(this._endianness(offset, 0, 2, littleEndian)),
+			b0 = this._getUint8(this._endianness(offset, 1, 2, littleEndian));
+
+		return (b1 << 8) + b0;
+	},
+
+	_getInt8: function (offset) {
+		var b = this._getUint8(offset);
+		return b > Math.pow(2, 7) - 1 ? b - Math.pow(2, 8) : b;
+	},
+
+	_getUint8: function (offset) {
+		if (this._isArrayBuffer) {
+			return new Uint8Array(this._buffer, this._start + offset, 1)[0];
+		} else {
+			return this._buffer.charCodeAt(this._start + offset) & 0xff;
+		}
+	}
+};
+
+// Create wrappers
+
+var dataTypes = {
+	'Int8': 1,
+	'Int16': 2,
+	'Int32': 4,
+	'Uint8': 1,
+	'Uint16': 2,
+	'Uint32': 4,
+	'Float32': 4,
+	'Float64': 8
+};
+
+for (var type in dataTypes) {
+	// Bind the variable type
+	(function (type) {
+		var size = dataTypes[type];
+
+		// Create the function
+		jDataView.prototype['get' + type] = 
+			function (byteOffset, littleEndian) {
+				var value;
+
+				// Handle the lack of endianness
+				if (littleEndian == undefined) {
+					littleEndian = this._littleEndian;
+				}
+
+				// Handle the lack of byteOffset
+				if (byteOffset === undefined) {
+					byteOffset = this._offset;
+				}
+
+				// Dispatch on the good method
+				if (this._isDataView) {
+					// DataView: we use the direct method
+					value = this._view['get' + type](byteOffset, littleEndian);
+				}
+				// ArrayBuffer: we use a typed array of size 1 if the alignment is good
+				// ArrayBuffer does not support endianess flag (for size > 1)
+				else if (this._isArrayBuffer && byteOffset % size == 0 && (size == 1 || littleEndian)) {
+					value = new window[type + 'Array'](this._buffer, byteOffset, 1)[0];
+				}
+				else {
+					// Error Checking
+					if (typeof byteOffset !== 'number') {
+						throw new TypeError("Type error");
+					}
+					if (byteOffset + size > this.length) {
+						throw new Error("INDEX_SIZE_ERR: DOM Exception 1");
+					}
+					value = this['_get' + type](this._start + byteOffset, littleEndian);
+				}
+
+				// Move the internal offset forward
+				this._offset = byteOffset + size;
+
+				return value;
+			};
+	})(type);
+}
+
+window.jDataView = jDataView;
+window.DataView = jDataView;
+})();

webserver/index.html

@@ -31,6 +31,16 @@
       l.innerHTML = l.innerHTML + spac + msg + "\n";
 
       }
+
+	function include(filename)
+	{
+	   document.write('<script type="text/javascript" src="' + filename + 
+	                  '"><' + '/script>');
+	}
+	
+	if(!window.DataView){
+		include("dataview.js");
+	}
     </script>
     <script src="jvm.js" type="text/javascript"></script>
   <meta http-equiv="Content-Type" content="text/html; charset=utf-8">