| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 import 'dart:_js_helper' show patch; | |
| 6 | |
| 7 @patch | |
| 8 class _Directory { | |
| 9 @patch | |
| 10 static _current() { | |
| 11 throw new UnsupportedError("Directory._current"); | |
| 12 } | |
| 13 @patch | |
| 14 static _setCurrent(path) { | |
| 15 throw new UnsupportedError("Directory_SetCurrent"); | |
| 16 } | |
| 17 @patch | |
| 18 static _createTemp(String path) { | |
| 19 throw new UnsupportedError("Directory._createTemp"); | |
| 20 } | |
| 21 @patch | |
| 22 static String _systemTemp() { | |
| 23 throw new UnsupportedError("Directory._systemTemp"); | |
| 24 } | |
| 25 @patch | |
| 26 static _exists(String path) { | |
| 27 throw new UnsupportedError("Directory._exists"); | |
| 28 } | |
| 29 @patch | |
| 30 static _create(String path) { | |
| 31 throw new UnsupportedError("Directory._create"); | |
| 32 } | |
| 33 @patch | |
| 34 static _deleteNative(String path, bool recursive) { | |
| 35 throw new UnsupportedError("Directory._deleteNative"); | |
| 36 } | |
| 37 @patch | |
| 38 static _rename(String path, String newPath) { | |
| 39 throw new UnsupportedError("Directory._rename"); | |
| 40 } | |
| 41 @patch | |
| 42 static List _list(String path, bool recursive, bool followLinks) { | |
| 43 throw new UnsupportedError("Directory._list"); | |
| 44 } | |
| 45 } | |
| 46 | |
| 47 @patch | |
| 48 class _EventHandler { | |
| 49 @patch | |
| 50 static void _sendData(Object sender, | |
| 51 SendPort sendPort, | |
| 52 int data) { | |
| 53 throw new UnsupportedError("EventHandler._sendData"); | |
| 54 } | |
| 55 } | |
| 56 | |
| 57 @patch | |
| 58 class FileStat { | |
| 59 @patch | |
| 60 static _statSync(String path) { | |
| 61 throw new UnsupportedError("FileStat.stat"); | |
| 62 } | |
| 63 } | |
| 64 | |
| 65 @patch | |
| 66 class FileSystemEntity { | |
| 67 @patch | |
| 68 static _getType(String path, bool followLinks) { | |
| 69 throw new UnsupportedError("FileSystemEntity._getType"); | |
| 70 } | |
| 71 @patch | |
| 72 static _identical(String path1, String path2) { | |
| 73 throw new UnsupportedError("FileSystemEntity._identical"); | |
| 74 } | |
| 75 @patch | |
| 76 static _resolveSymbolicLinks(String path) { | |
| 77 throw new UnsupportedError("FileSystemEntity._resolveSymbolicLinks"); | |
| 78 } | |
| 79 } | |
| 80 | |
| 81 @patch | |
| 82 class _File { | |
| 83 @patch | |
| 84 static _exists(String path) { | |
| 85 throw new UnsupportedError("File._exists"); | |
| 86 } | |
| 87 @patch | |
| 88 static _create(String path) { | |
| 89 throw new UnsupportedError("File._create"); | |
| 90 } | |
| 91 @patch | |
| 92 static _createLink(String path, String target) { | |
| 93 throw new UnsupportedError("File._createLink"); | |
| 94 } | |
| 95 @patch | |
| 96 static _linkTarget(String path) { | |
| 97 throw new UnsupportedError("File._linkTarget"); | |
| 98 } | |
| 99 @patch | |
| 100 static _deleteNative(String path) { | |
| 101 throw new UnsupportedError("File._deleteNative"); | |
| 102 } | |
| 103 @patch | |
| 104 static _deleteLinkNative(String path) { | |
| 105 throw new UnsupportedError("File._deleteLinkNative"); | |
| 106 } | |
| 107 @patch | |
| 108 static _rename(String oldPath, String newPath) { | |
| 109 throw new UnsupportedError("File._rename"); | |
| 110 } | |
| 111 @patch | |
| 112 static _renameLink(String oldPath, String newPath) { | |
| 113 throw new UnsupportedError("File._renameLink"); | |
| 114 } | |
| 115 @patch | |
| 116 static _copy(String oldPath, String newPath) { | |
| 117 throw new UnsupportedError("File._copy"); | |
| 118 } | |
| 119 @patch | |
| 120 static _lengthFromPath(String path) { | |
| 121 throw new UnsupportedError("File._lengthFromPath"); | |
| 122 } | |
| 123 @patch | |
| 124 static _lastModified(String path) { | |
| 125 throw new UnsupportedError("File._lastModified"); | |
| 126 } | |
| 127 @patch | |
| 128 static _open(String path, int mode) { | |
| 129 throw new UnsupportedError("File._open"); | |
| 130 } | |
| 131 @patch | |
| 132 static int _openStdio(int fd) { | |
| 133 throw new UnsupportedError("File._openStdio"); | |
| 134 } | |
| 135 } | |
| 136 | |
| 137 @patch | |
| 138 class _RandomAccessFile { | |
| 139 @patch | |
| 140 static int _close(int id) { | |
| 141 throw new UnsupportedError("RandomAccessFile._close"); | |
| 142 } | |
| 143 @patch | |
| 144 static int _getFD(int id) { | |
| 145 throw new UnsupportedError("RandomAccessFile._getFD"); | |
| 146 } | |
| 147 @patch | |
| 148 static _readByte(int id) { | |
| 149 throw new UnsupportedError("RandomAccessFile._readByte"); | |
| 150 } | |
| 151 @patch | |
| 152 static _read(int id, int bytes) { | |
| 153 throw new UnsupportedError("RandomAccessFile._read"); | |
| 154 } | |
| 155 @patch | |
| 156 static _readInto(int id, List<int> buffer, int start, int end) { | |
| 157 throw new UnsupportedError("RandomAccessFile._readInto"); | |
| 158 } | |
| 159 @patch | |
| 160 static _writeByte(int id, int value) { | |
| 161 throw new UnsupportedError("RandomAccessFile._writeByte"); | |
| 162 } | |
| 163 @patch | |
| 164 static _writeFrom(int id, List<int> buffer, int start, int end) { | |
| 165 throw new UnsupportedError("RandomAccessFile._writeFrom"); | |
| 166 } | |
| 167 @patch | |
| 168 static _position(int id) { | |
| 169 throw new UnsupportedError("RandomAccessFile._position"); | |
| 170 } | |
| 171 @patch | |
| 172 static _setPosition(int id, int position) { | |
| 173 throw new UnsupportedError("RandomAccessFile._setPosition"); | |
| 174 } | |
| 175 @patch | |
| 176 static _truncate(int id, int length) { | |
| 177 throw new UnsupportedError("RandomAccessFile._truncate"); | |
| 178 } | |
| 179 @patch | |
| 180 static _length(int id) { | |
| 181 throw new UnsupportedError("RandomAccessFile._length"); | |
| 182 } | |
| 183 @patch | |
| 184 static _flush(int id) { | |
| 185 throw new UnsupportedError("RandomAccessFile._flush"); | |
| 186 } | |
| 187 @patch | |
| 188 static _lock(int id, int lock, int start, int end) { | |
| 189 throw new UnsupportedError("RandomAccessFile._lock"); | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 @patch | |
| 194 class _IOCrypto { | |
| 195 @patch | |
| 196 static Uint8List getRandomBytes(int count) { | |
| 197 throw new UnsupportedError("_IOCrypto.getRandomBytes"); | |
| 198 } | |
| 199 } | |
| 200 | |
| 201 @patch | |
| 202 class _Platform { | |
| 203 @patch | |
| 204 static int _numberOfProcessors() { | |
| 205 throw new UnsupportedError("Platform._numberOfProcessors"); | |
| 206 } | |
| 207 @patch | |
| 208 static String _pathSeparator() { | |
| 209 throw new UnsupportedError("Platform._pathSeparator"); | |
| 210 } | |
| 211 @patch | |
| 212 static String _operatingSystem() { | |
| 213 throw new UnsupportedError("Platform._operatingSystem"); | |
| 214 } | |
| 215 @patch | |
| 216 static _localHostname() { | |
| 217 throw new UnsupportedError("Platform._localHostname"); | |
| 218 } | |
| 219 @patch | |
| 220 static _executable() { | |
| 221 throw new UnsupportedError("Platform._executable"); | |
| 222 } | |
| 223 @patch | |
| 224 static _resolvedExecutable() { | |
| 225 throw new UnsupportedError("Platform._resolvedExecutable"); | |
| 226 } | |
| 227 @patch | |
| 228 static List<String> _executableArguments() { | |
| 229 throw new UnsupportedError("Platform._executableArguments"); | |
| 230 } | |
| 231 @patch | |
| 232 static String _packageRoot() { | |
| 233 throw new UnsupportedError("Platform._packageRoot"); | |
| 234 } | |
| 235 @patch | |
| 236 static _environment() { | |
| 237 throw new UnsupportedError("Platform._environment"); | |
| 238 } | |
| 239 @patch | |
| 240 static String _version() { | |
| 241 throw new UnsupportedError("Platform._version"); | |
| 242 } | |
| 243 } | |
| 244 | |
| 245 @patch | |
| 246 class _ProcessUtils { | |
| 247 @patch | |
| 248 static void _exit(int status) { | |
| 249 throw new UnsupportedError("ProcessUtils._exit"); | |
| 250 } | |
| 251 @patch | |
| 252 static void _setExitCode(int status) { | |
| 253 throw new UnsupportedError("ProcessUtils._setExitCode"); | |
| 254 } | |
| 255 @patch | |
| 256 static int _getExitCode() { | |
| 257 throw new UnsupportedError("ProcessUtils._getExitCode"); | |
| 258 } | |
| 259 @patch | |
| 260 static void _sleep(int millis) { | |
| 261 throw new UnsupportedError("ProcessUtils._sleep"); | |
| 262 } | |
| 263 @patch | |
| 264 static int _pid(Process process) { | |
| 265 throw new UnsupportedError("ProcessUtils._pid"); | |
| 266 } | |
| 267 @patch | |
| 268 static Stream<ProcessSignal> _watchSignal(ProcessSignal signal) { | |
| 269 throw new UnsupportedError("ProcessUtils._watchSignal"); | |
| 270 } | |
| 271 } | |
| 272 | |
| 273 @patch | |
| 274 class Process { | |
| 275 @patch | |
| 276 static Future<Process> start( | |
| 277 String executable, | |
| 278 List<String> arguments, | |
| 279 {String workingDirectory, | |
| 280 Map<String, String> environment, | |
| 281 bool includeParentEnvironment: true, | |
| 282 bool runInShell: false, | |
| 283 ProcessStartMode mode: ProcessStartMode.NORMAL}) { | |
| 284 throw new UnsupportedError("Process.start"); | |
| 285 } | |
| 286 | |
| 287 @patch | |
| 288 static Future<ProcessResult> run( | |
| 289 String executable, | |
| 290 List<String> arguments, | |
| 291 {String workingDirectory, | |
| 292 Map<String, String> environment, | |
| 293 bool includeParentEnvironment: true, | |
| 294 bool runInShell: false, | |
| 295 Encoding stdoutEncoding: SYSTEM_ENCODING, | |
| 296 Encoding stderrEncoding: SYSTEM_ENCODING}) { | |
| 297 throw new UnsupportedError("Process.run"); | |
| 298 } | |
| 299 | |
| 300 @patch | |
| 301 static ProcessResult runSync( | |
| 302 String executable, | |
| 303 List<String> arguments, | |
| 304 {String workingDirectory, | |
| 305 Map<String, String> environment, | |
| 306 bool includeParentEnvironment: true, | |
| 307 bool runInShell: false, | |
| 308 Encoding stdoutEncoding: SYSTEM_ENCODING, | |
| 309 Encoding stderrEncoding: SYSTEM_ENCODING}) { | |
| 310 throw new UnsupportedError("Process.runSync"); | |
| 311 } | |
| 312 | |
| 313 @patch | |
| 314 static bool killPid( | |
| 315 int pid, [ProcessSignal signal = ProcessSignal.SIGTERM]) { | |
| 316 throw new UnsupportedError("Process.killPid"); | |
| 317 } | |
| 318 } | |
| 319 | |
| 320 @patch | |
| 321 class InternetAddress { | |
| 322 @patch | |
| 323 static InternetAddress get LOOPBACK_IP_V4 { | |
| 324 throw new UnsupportedError("InternetAddress.LOOPBACK_IP_V4"); | |
| 325 } | |
| 326 @patch | |
| 327 static InternetAddress get LOOPBACK_IP_V6 { | |
| 328 throw new UnsupportedError("InternetAddress.LOOPBACK_IP_V6"); | |
| 329 } | |
| 330 @patch | |
| 331 static InternetAddress get ANY_IP_V4 { | |
| 332 throw new UnsupportedError("InternetAddress.ANY_IP_V4"); | |
| 333 } | |
| 334 @patch | |
| 335 static InternetAddress get ANY_IP_V6 { | |
| 336 throw new UnsupportedError("InternetAddress.ANY_IP_V6"); | |
| 337 } | |
| 338 @patch | |
| 339 factory InternetAddress(String address) { | |
| 340 throw new UnsupportedError("InternetAddress"); | |
| 341 } | |
| 342 @patch | |
| 343 static Future<List<InternetAddress>> lookup( | |
| 344 String host, {InternetAddressType type: InternetAddressType.ANY}) { | |
| 345 throw new UnsupportedError("InternetAddress.lookup"); | |
| 346 } | |
| 347 } | |
| 348 | |
| 349 @patch | |
| 350 class NetworkInterface { | |
| 351 @patch | |
| 352 static Future<List<NetworkInterface>> list({ | |
| 353 bool includeLoopback: false, | |
| 354 bool includeLinkLocal: false, | |
| 355 InternetAddressType type: InternetAddressType.ANY}) { | |
| 356 throw new UnsupportedError("NetworkInterface.list"); | |
| 357 } | |
| 358 } | |
| 359 | |
| 360 @patch | |
| 361 class RawServerSocket { | |
| 362 @patch | |
| 363 static Future<RawServerSocket> bind(address, | |
| 364 int port, | |
| 365 {int backlog: 0, | |
| 366 bool v6Only: false, | |
| 367 bool shared: false}) { | |
| 368 throw new UnsupportedError("RawServerSocket.bind"); | |
| 369 } | |
| 370 } | |
| 371 | |
| 372 @patch | |
| 373 class ServerSocket { | |
| 374 @patch | |
| 375 static Future<ServerSocket> bind(address, | |
| 376 int port, | |
| 377 {int backlog: 0, | |
| 378 bool v6Only: false, | |
| 379 bool shared: false}) { | |
| 380 throw new UnsupportedError("ServerSocket.bind"); | |
| 381 } | |
| 382 } | |
| 383 | |
| 384 @patch | |
| 385 class RawSocket { | |
| 386 @patch | |
| 387 static Future<RawSocket> connect(host, int port, {sourceAddress}) { | |
| 388 throw new UnsupportedError("RawSocket constructor"); | |
| 389 } | |
| 390 } | |
| 391 | |
| 392 @patch | |
| 393 class Socket { | |
| 394 @patch | |
| 395 static Future<Socket> connect(host, int port, {sourceAddress}) { | |
| 396 throw new UnsupportedError("Socket constructor"); | |
| 397 } | |
| 398 } | |
| 399 | |
| 400 @patch | |
| 401 class SecureSocket { | |
| 402 @patch | |
| 403 factory SecureSocket._(RawSecureSocket rawSocket) { | |
| 404 throw new UnsupportedError("SecureSocket constructor"); | |
| 405 } | |
| 406 | |
| 407 @patch | |
| 408 static void initialize({String database, | |
| 409 String password, | |
| 410 bool useBuiltinRoots: true}) { | |
| 411 throw new UnsupportedError("SecureSocket.initialize"); | |
| 412 } | |
| 413 } | |
| 414 | |
| 415 @patch | |
| 416 class RawDatagramSocket { | |
| 417 @patch | |
| 418 static Future<RawDatagramSocket> bind( | |
| 419 host, int port, {bool reuseAddress: true}) { | |
| 420 throw new UnsupportedError("RawDatagramSocket.bind"); | |
| 421 } | |
| 422 } | |
| 423 | |
| 424 @patch | |
| 425 class _SecureFilter { | |
| 426 @patch | |
| 427 factory _SecureFilter() { | |
| 428 throw new UnsupportedError("_SecureFilter._SecureFilter"); | |
| 429 } | |
| 430 } | |
| 431 | |
| 432 @patch | |
| 433 class _StdIOUtils { | |
| 434 @patch | |
| 435 static Stdin _getStdioInputStream() { | |
| 436 throw new UnsupportedError("StdIOUtils._getStdioInputStream"); | |
| 437 } | |
| 438 @patch | |
| 439 static _getStdioOutputStream(int fd) { | |
| 440 throw new UnsupportedError("StdIOUtils._getStdioOutputStream"); | |
| 441 } | |
| 442 @patch | |
| 443 static int _socketType(nativeSocket) { | |
| 444 throw new UnsupportedError("StdIOUtils._socketType"); | |
| 445 } | |
| 446 @patch | |
| 447 static _getStdioHandleType(int fd) { | |
| 448 throw new UnsupportedError("StdIOUtils._getStdioHandleType"); | |
| 449 } | |
| 450 } | |
| 451 | |
| 452 @patch | |
| 453 class _WindowsCodePageDecoder { | |
| 454 @patch | |
| 455 static String _decodeBytes(List<int> bytes) { | |
| 456 throw new UnsupportedError("_WindowsCodePageDecoder._decodeBytes"); | |
| 457 } | |
| 458 } | |
| 459 | |
| 460 @patch | |
| 461 class _WindowsCodePageEncoder { | |
| 462 @patch | |
| 463 static List<int> _encodeString(String string) { | |
| 464 throw new UnsupportedError("_WindowsCodePageEncoder._encodeString"); | |
| 465 } | |
| 466 } | |
| 467 | |
| 468 @patch | |
| 469 class _Filter { | |
| 470 @patch | |
| 471 static _Filter _newZLibDeflateFilter(bool gzip, int level, | |
| 472 int windowBits, int memLevel, | |
| 473 int strategy, | |
| 474 List<int> dictionary, bool raw) { | |
| 475 throw new UnsupportedError("_newZLibDeflateFilter"); | |
| 476 } | |
| 477 @patch | |
| 478 static _Filter _newZLibInflateFilter(int windowBits, | |
| 479 List<int> dictionary, bool raw) { | |
| 480 throw new UnsupportedError("_newZLibInflateFilter"); | |
| 481 } | |
| 482 } | |
| 483 | |
| 484 @patch | |
| 485 class Stdin { | |
| 486 @patch | |
| 487 int readByteSync() { | |
| 488 throw new UnsupportedError("Stdin.readByteSync"); | |
| 489 } | |
| 490 @patch | |
| 491 bool get echoMode { | |
| 492 throw new UnsupportedError("Stdin.echoMode"); | |
| 493 } | |
| 494 @patch | |
| 495 void set echoMode(bool enabled) { | |
| 496 throw new UnsupportedError("Stdin.echoMode"); | |
| 497 } | |
| 498 @patch | |
| 499 bool get lineMode { | |
| 500 throw new UnsupportedError("Stdin.lineMode"); | |
| 501 } | |
| 502 @patch | |
| 503 void set lineMode(bool enabled) { | |
| 504 throw new UnsupportedError("Stdin.lineMode"); | |
| 505 } | |
| 506 } | |
| 507 | |
| 508 @patch | |
| 509 class Stdout { | |
| 510 @patch | |
| 511 bool _hasTerminal(int fd) { | |
| 512 throw new UnsupportedError("Stdout.hasTerminal"); | |
| 513 } | |
| 514 @patch | |
| 515 int _terminalColumns(int fd) { | |
| 516 throw new UnsupportedError("Stdout.terminalColumns"); | |
| 517 } | |
| 518 @patch | |
| 519 int _terminalLines(int fd) { | |
| 520 throw new UnsupportedError("Stdout.terminalLines"); | |
| 521 } | |
| 522 } | |
| 523 | |
| 524 @patch | |
| 525 class _FileSystemWatcher { | |
| 526 @patch | |
| 527 static Stream<FileSystemEvent> _watch( | |
| 528 String path, int events, bool recursive) { | |
| 529 throw new UnsupportedError("_FileSystemWatcher.watch"); | |
| 530 } | |
| 531 @patch | |
| 532 static bool get isSupported { | |
| 533 throw new UnsupportedError("_FileSystemWatcher.isSupported"); | |
| 534 } | |
| 535 } | |
| 536 | |
| 537 @patch | |
| 538 class _IOService { | |
| 539 @patch | |
| 540 static Future _dispatch(int request, List data) { | |
| 541 throw new UnsupportedError("_IOService._dispatch"); | |
| 542 } | |
| 543 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1212513002:
sdk files reorganization to make dart2js a proper package (Closed)
Base URL: git@github.com:dart-lang/sdk.git@master