OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 // Support for parsing binary sequences encoded as readable strings |
| 6 // or ".data" files. The input format is described here: |
| 7 // mojo/public/cpp/bindings/tests/validation_test_input_parser.h |
| 8 |
| 9 define([ |
| 10 "mojo/public/js/bindings/buffer" |
| 11 ], function(buffer) { |
| 12 |
| 13 // Files and Lines represent the raw text from an input string |
| 14 // or ".data" file. |
| 15 |
| 16 function InputError(message, line) { |
| 17 this.message = message; |
| 18 this.line = line; |
| 19 } |
| 20 |
| 21 InputError.prototype.toString = function() { |
| 22 var s = 'Error: ' + this.message; |
| 23 if (this.line) |
| 24 s += ', at line ' + |
| 25 (this.line.number + 1) + ': "' + this.line.contents + '"'; |
| 26 return s; |
| 27 } |
| 28 |
| 29 function File(contents) { |
| 30 this.contents = contents; |
| 31 this.index = 0; |
| 32 this.lineNumber = 0; |
| 33 } |
| 34 |
| 35 File.prototype.endReached = function() { |
| 36 return this.index >= this.contents.length; |
| 37 } |
| 38 |
| 39 File.prototype.nextLine = function() { |
| 40 if (this.endReached()) |
| 41 return null; |
| 42 var start = this.index; |
| 43 var end = this.contents.indexOf('\n', start); |
| 44 if (end == -1) |
| 45 end = this.contents.length; |
| 46 this.index = end + 1; |
| 47 return new Line(this.contents.substring(start, end), this.lineNumber++); |
| 48 } |
| 49 |
| 50 function Line(contents, number) { |
| 51 var i = contents.indexOf('//'); |
| 52 var s = (i == -1) ? contents.trim() : contents.substring(0, i).trim(); |
| 53 this.contents = contents; |
| 54 this.items = (s.length > 0) ? s.split(/\s+/) : []; |
| 55 this.index = 0; |
| 56 this.number = number; |
| 57 } |
| 58 |
| 59 Line.prototype.endReached = function() { |
| 60 return this.index >= this.items.length; |
| 61 } |
| 62 |
| 63 var ITEM_TYPE_SIZES = { |
| 64 u1: 1, u2: 2, u4: 4, u8: 8, s1: 1, s2: 2, s4: 4, s8: 8, b: 1, f: 4, d: 8, |
| 65 dist4: 4, dist8: 8, anchr: 0, handles: 0 |
| 66 }; |
| 67 |
| 68 function isValidItemType(type) { |
| 69 return ITEM_TYPE_SIZES[type] !== undefined; |
| 70 } |
| 71 |
| 72 Line.prototype.nextItem = function() { |
| 73 if (this.endReached()) |
| 74 return null; |
| 75 |
| 76 var itemString = this.items[this.index++]; |
| 77 var type = 'u1'; |
| 78 var value = itemString; |
| 79 |
| 80 if (itemString.charAt(0) == '[') { |
| 81 var i = itemString.indexOf(']'); |
| 82 if (i != -1 && i + 1 < itemString.length) { |
| 83 type = itemString.substring(1, i); |
| 84 value = itemString.substring(i + 1); |
| 85 } else { |
| 86 throw new InputError('invalid item', this); |
| 87 } |
| 88 } |
| 89 if (!isValidItemType(type)) |
| 90 throw new InputError('invalid item type', this); |
| 91 |
| 92 return new Item(this, type, value); |
| 93 } |
| 94 |
| 95 // The text for each whitespace delimited binary data "item" is represented |
| 96 // by an Item. |
| 97 |
| 98 function Item(line, type, value) { |
| 99 this.line = line; |
| 100 this.type = type; |
| 101 this.value = value; |
| 102 this.size = ITEM_TYPE_SIZES[type]; |
| 103 } |
| 104 |
| 105 Item.prototype.isFloat = function() { |
| 106 return this.type == 'f' || this.type == 'd'; |
| 107 } |
| 108 |
| 109 Item.prototype.isInteger = function() { |
| 110 return ['u1', 'u2', 'u4', 'u8', |
| 111 's1', 's2', 's4', 's8'].indexOf(this.type) != -1; |
| 112 } |
| 113 |
| 114 Item.prototype.isNumber = function() { |
| 115 return this.isFloat() || this.isInteger(); |
| 116 } |
| 117 |
| 118 Item.prototype.isByte = function() { |
| 119 return this.type == 'b'; |
| 120 } |
| 121 |
| 122 Item.prototype.isDistance = function() { |
| 123 return this.type == 'dist4' || this.type == 'dist8'; |
| 124 } |
| 125 |
| 126 Item.prototype.isAnchor = function() { |
| 127 return this.type == 'anchr'; |
| 128 } |
| 129 |
| 130 Item.prototype.isHandles = function() { |
| 131 return this.type == 'handles'; |
| 132 } |
| 133 |
| 134 // A TestMessage represents the complete binary message loaded from an input |
| 135 // string or ".data" file. The parseTestMessage() function below constructs |
| 136 // a TestMessage from a File. |
| 137 |
| 138 function TestMessage(byteLength) { |
| 139 this.index = 0; |
| 140 this.buffer = new buffer.Buffer(byteLength); |
| 141 this.distances = {}; |
| 142 this.handleCount = 0; |
| 143 } |
| 144 |
| 145 function checkItemNumberValue(item, n, min, max) { |
| 146 if (n < min || n > max) |
| 147 throw new InputError('invalid item value', item.line); |
| 148 } |
| 149 |
| 150 TestMessage.prototype.addNumber = function(item) { |
| 151 var n = item.isInteger() ? parseInt(item.value) : parseFloat(item.value); |
| 152 if (Number.isNaN(n)) |
| 153 throw new InputError("can't parse item value", item.line); |
| 154 |
| 155 switch(item.type) { |
| 156 case 'u1': |
| 157 checkItemNumberValue(item, n, 0, 0xFF); |
| 158 this.buffer.setUint8(this.index, n); |
| 159 break; |
| 160 case 'u2': |
| 161 checkItemNumberValue(item, n, 0, 0xFFFF); |
| 162 this.buffer.setUint16(this.index, n); |
| 163 break; |
| 164 case 'u4': |
| 165 checkItemNumberValue(item, n, 0, 0xFFFFFFFF); |
| 166 this.buffer.setUint32(this.index, n); |
| 167 break; |
| 168 case 'u8': |
| 169 checkItemNumberValue(item, n, 0, Number.MAX_SAFE_INTEGER); |
| 170 this.buffer.setUint64(this.index, n); |
| 171 break; |
| 172 case 's1': |
| 173 checkItemNumberValue(item, n, -128, 127); |
| 174 this.buffer.setInt8(this.index, n); |
| 175 break; |
| 176 case 's2': |
| 177 checkItemNumberValue(item, n, -32768, 32767); |
| 178 this.buffer.setInt16(this.index, n); |
| 179 break; |
| 180 case 's4': |
| 181 checkItemNumberValue(item, n, -2147483648, 2147483647); |
| 182 this.buffer.setInt32(this.index, n); |
| 183 break; |
| 184 case 's8': |
| 185 checkItemNumberValue(item, n, |
| 186 Number.MIN_SAFE_INTEGER, |
| 187 Number.MAX_SAFE_INTEGER); |
| 188 this.buffer.setInt64(this.index, n); |
| 189 break; |
| 190 case 'f': |
| 191 this.buffer.setFloat32(this.index, n); |
| 192 break; |
| 193 case 'd': |
| 194 this.buffer.setFloat64(this.index, n); |
| 195 break; |
| 196 |
| 197 default: |
| 198 throw new InputError('unrecognized item type', item.line); |
| 199 } |
| 200 } |
| 201 |
| 202 TestMessage.prototype.addByte = function(item) { |
| 203 if (!/^[01]{8}$/.test(item.value)) |
| 204 throw new InputError('invalid byte item value', item.line); |
| 205 function b(i) { |
| 206 return (item.value.charAt(7 - i) == '1') ? 1 << i : 0; |
| 207 } |
| 208 var n = b(0) | b(1) | b(2) | b(3) | b(4) | b(5) | b(6) | b(7); |
| 209 this.buffer.setUint8(this.index, n); |
| 210 } |
| 211 |
| 212 TestMessage.prototype.addDistance = function(item) { |
| 213 if (this.distances[item.value]) |
| 214 throw new InputError('duplicate distance item', item.line); |
| 215 this.distances[item.value] = {index: this.index, item: item}; |
| 216 } |
| 217 |
| 218 TestMessage.prototype.addAnchor = function(item) { |
| 219 var dist = this.distances[item.value]; |
| 220 if (!dist) |
| 221 throw new InputError('unmatched anchor item', item.line); |
| 222 delete this.distances[item.value]; |
| 223 |
| 224 var n = this.index - dist.index; |
| 225 // TODO(hansmuller): validate n |
| 226 |
| 227 if (dist.item.type == 'dist4') |
| 228 this.buffer.setUint32(dist.index, n); |
| 229 else if (dist.item.type == 'dist8') |
| 230 this.buffer.setUint64(dist.index, n); |
| 231 else |
| 232 throw new InputError('unrecognzed distance item type', dist.item.line); |
| 233 } |
| 234 |
| 235 TestMessage.prototype.addHandles = function(item) { |
| 236 this.handleCount = parseInt(item.value); |
| 237 if (Number.isNaN(this.handleCount)) |
| 238 throw new InputError("can't parse handleCount", item.line); |
| 239 } |
| 240 |
| 241 TestMessage.prototype.addItem = function(item) { |
| 242 if (item.isNumber()) |
| 243 this.addNumber(item); |
| 244 else if (item.isByte()) |
| 245 this.addByte(item); |
| 246 else if (item.isDistance()) |
| 247 this.addDistance(item); |
| 248 else if (item.isAnchor()) |
| 249 this.addAnchor(item); |
| 250 else if (item.isHandles()) |
| 251 this.addHandles(item); |
| 252 else |
| 253 throw new InputError('unrecognized item type', item.line); |
| 254 |
| 255 this.index += item.size; |
| 256 } |
| 257 |
| 258 TestMessage.prototype.unanchoredDistances = function() { |
| 259 var names = null; |
| 260 for (var name in this.distances) { |
| 261 if (this.distances.hasOwnProperty(name)) |
| 262 names = (names === null) ? name : names + ' ' + name; |
| 263 } |
| 264 return names; |
| 265 } |
| 266 |
| 267 function parseTestMessage(text) { |
| 268 var file = new File(text); |
| 269 var items = []; |
| 270 var messageLength = 0; |
| 271 while(!file.endReached()) { |
| 272 var line = file.nextLine(); |
| 273 while (!line.endReached()) { |
| 274 var item = line.nextItem(); |
| 275 if (item.isHandles() && items.length > 0) |
| 276 throw new InputError('handles item is not first'); |
| 277 messageLength += item.size; |
| 278 items.push(item); |
| 279 } |
| 280 } |
| 281 |
| 282 var msg = new TestMessage(messageLength); |
| 283 for (var i = 0; i < items.length; i++) |
| 284 msg.addItem(items[i]); |
| 285 |
| 286 if (messageLength != msg.index) |
| 287 throw new InputError('failed to compute message length'); |
| 288 var names = msg.unanchoredDistances(); |
| 289 if (names) |
| 290 throw new InputError('no anchors for ' + names, 0); |
| 291 |
| 292 return msg; |
| 293 } |
| 294 |
| 295 var exports = {}; |
| 296 exports.parseTestMessage = parseTestMessage; |
| 297 exports.InputError = InputError; |
| 298 return exports; |
| 299 }); |
OLD | NEW |