Work in progres, please take a look and give early feedback if this is the way we want to structure…

lib/io/system_posix.dart

 // Copyright (c) 2014, the Fletch project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
 part of system;
 
 const int AF_INET  = 2;
 const int AF_INET6 = 10;
 
 const int SOCK_STREAM = 1;
@@ skipping 38 matching lines @@
   int get _addrlenOffset => 16;
 
   int get ai_flags => getInt32(0);
   int get ai_family => getInt32(4);
   void set ai_family(int value) { setInt32(4, value); }
   int get ai_socktype => getInt32(8);
   int get ai_protocol => getInt32(12);
 
   int get ai_addrlen => getInt32(_addrlenOffset);
 
-  Foreign get ai_addr;
+  ForeignMemory get ai_addr;
   get ai_canonname;
   AddrInfo get ai_next;
 }
 
 abstract class PosixSystem implements System {
-  static final Foreign _accept = Foreign.lookup("accept");
-  static final Foreign _access = Foreign.lookup("access");
-  static final Foreign _bind = Foreign.lookup("bind");
-  static final Foreign _close = Foreign.lookup("close");
-  static final Foreign _connect = Foreign.lookup("connect");
-  static final Foreign _fcntl = Foreign.lookup("fcntl");
-  static final Foreign _freeaddrinfo = Foreign.lookup("freeaddrinfo");
-  static final Foreign _getaddrinfo = Foreign.lookup("getaddrinfo");
-  static final Foreign _getsockname = Foreign.lookup("getsockname");
-  static final Foreign _ioctl = Foreign.lookup("ioctl");
-  static final Foreign _listen = Foreign.lookup("listen");
-  static final Foreign _memcpy = Foreign.lookup("memcpy");
-  static final Foreign _mkstemp = Foreign.lookup("mkstemp");
-  static final Foreign _nanosleep = Foreign.lookup("nanosleep");
-  static final Foreign _read = Foreign.lookup("read");
-  static final Foreign _setsockopt = Foreign.lookup("setsockopt");
-  static final Foreign _shutdown = Foreign.lookup("shutdown");
-  static final Foreign _socket = Foreign.lookup("socket");
-  static final Foreign _unlink = Foreign.lookup("unlink");
-  static final Foreign _write = Foreign.lookup("write");
+  static final ForeignFunction _accept =
+      ForeignLibrary.standard.lookup("accept");
+  static final ForeignFunction _access =
+      ForeignLibrary.standard.lookup("access");
+  static final ForeignFunction _bind = ForeignLibrary.standard.lookup("bind");

[kasperl, 2015/07/03 07:49:54]

I'd prefer to break all the lines the same way to make the formatting more
consistent. So even for the cases where it fits on one line, I prefer splitting.
I'm weird. Thanks for asking.

[ricow1, 2015/07/03 08:57:25]

Done.

+  static final ForeignFunction _close = ForeignLibrary.standard.lookup("close");
+  static final ForeignFunction _connect =
+      ForeignLibrary.standard.lookup("connect");
+  static final ForeignFunction _fcntl = ForeignLibrary.standard.lookup("fcntl");
+  static final ForeignFunction _freeaddrinfo =
+      ForeignLibrary.standard.lookup("freeaddrinfo");
+  static final ForeignFunction _getaddrinfo =
+      ForeignLibrary.standard.lookup("getaddrinfo");
+  static final ForeignFunction _getsockname =
+      ForeignLibrary.standard.lookup("getsockname");
+  static final ForeignFunction _ioctl = ForeignLibrary.standard.lookup("ioctl");
+  static final ForeignFunction _listen =
+      ForeignLibrary.standard.lookup("listen");
+  static final ForeignFunction _memcpy =
+      ForeignLibrary.standard.lookup("memcpy");
+  static final ForeignFunction _mkstemp =
+      ForeignLibrary.standard.lookup("mkstemp");
+  static final ForeignFunction _nanosleep =
+      ForeignLibrary.standard.lookup("nanosleep");
+  static final ForeignFunction _read = ForeignLibrary.standard.lookup("read");
+  static final ForeignFunction _setsockopt =
+      ForeignLibrary.standard.lookup("setsockopt");
+  static final ForeignFunction _shutdown =
+      ForeignLibrary.standard.lookup("shutdown");
+  static final ForeignFunction _socket =
+      ForeignLibrary.standard.lookup("socket");
+  static final ForeignFunction _unlink =
+      ForeignLibrary.standard.lookup("unlink");
+  static final ForeignFunction _write = ForeignLibrary.standard.lookup("write");
 
   int get FIONREAD;
 
   int get SOL_SOCKET;
 
   int get SO_REUSEADDR;
 
-  Foreign get _open;
-  Foreign get _lseek;
+  ForeignFunction get _open;
+  ForeignFunction get _lseek;
 
   int socket() {
     return _retry(() => _socket.icall$3(AF_INET, SOCK_STREAM, 0));
   }
 
   InternetAddress lookup(String host) {
-    Foreign node = new Foreign.fromString(host);
+    ForeignMemory node = new ForeignMemory.fromString(host);
     // TODO(ajohnsen): Actually apply hints.
     AddrInfo hints = new AddrInfo();
     // TODO(ajohnsen): Allow IPv6 results.
     hints.ai_family = AF_INET;
     Struct result = new Struct(1);
     int status = _retry(() => _getaddrinfo.icall$4(node,
                                                    Foreign.NULL,
                                                    hints,
                                                    result));
     AddrInfo start = new AddrInfo.fromAddress(result.getField(0));
     AddrInfo info = start;
     var address;
-    while (info.value != 0) {
+    while (info.address != 0) {
       int length;
       int offset;
       // Loop until we find the right type.
       if (info.ai_family == AF_INET) {
         length = 4;
         offset = 4;
       } else if (info.ai_family == AF_INET6) {
         length = 16;
         offset = 8;
       } else {
         info = info.ai_next;
         continue;
       }
-      Foreign addr = info.ai_addr;
+      ForeignMemory addr = info.ai_addr;
       List<int> bytes = new List<int>(length);
       addr.copyBytesToList(bytes, offset, offset + length, 0);
       address = new _InternetAddress(bytes);
       break;
     }
     _freeaddrinfo.icall$1(start);
     node.free();
     hints.free();
     result.free();
     if (status != 0) throw "Failed to call 'getaddrinfo': ${errno()}";
     return address;
   }
 
   int open(String path, bool write, bool append) {
     int flags = O_RDONLY;
     if (write || append) {
       flags = O_RDWR | O_CREAT;
       if (append) flags = flags | O_TRUNC;
     }
     flags |= O_CLOEXEC;
-    Foreign cPath = new Foreign.fromString(path);
+    ForeignMemory cPath = new ForeignMemory.fromString(path);
     int fd = _retry(() => _open.icall$2(cPath, flags));
     cPath.free();
     return fd;
   }
 
   int lseek(int fd, int offset, int whence) {
     return _retry(() => _lseek.Lcall$wLw(fd, offset, whence));
   }
 
   TempFile mkstemp(String path) {
-    Foreign cPath = new Foreign.fromString(path + "XXXXXX");
+    ForeignMemory cPath = new ForeignMemory.fromString(path + "XXXXXX");
     int result = _retry(() => _mkstemp.icall$1(cPath));
     if (result != -1) {
       var bytes = new List(cPath.length - 1);
       cPath.copyBytesToList(bytes, 0, cPath.length - 1, 0);
       path = new String.fromCharCodes(bytes);
     }
     cPath.free();
     return new TempFile(result, path);
   }
 
   int access(String path) {
-    Foreign cPath = new Foreign.fromString(path);
+    ForeignMemory cPath = new ForeignMemory.fromString(path);
     int result = _retry(() => _access.icall$2(cPath, 0));
     cPath.free();
     return result;
   }
 
   int unlink(String path) {
-    Foreign cPath = new Foreign.fromString(path);
+    ForeignMemory cPath = new ForeignMemory.fromString(path);
     int result = _retry(() => _unlink.icall$1(cPath));
     cPath.free();
     return result;
   }
 
   int bind(int fd, _InternetAddress address, int port) {
-    Foreign sockaddr = _createSocketAddress(address, port);
+    ForeignMemory sockaddr = _createSocketAddress(address, port);
     int status = _retry(() => _bind.icall$3(fd, sockaddr, sockaddr.length));
     sockaddr.free();
     return status;
   }
 
   int listen(int fd) {
     return _retry(() => _listen.icall$2(fd, 128));
   }
 
   int setsockopt(int fd, int level, int optname, int value) {
     Struct32 opt = new Struct32(1);
     opt.setField(0, value);
     int result = _retry(() => _setsockopt.icall$5(fd,
                                                   level,
                                                   optname,
                                                   opt,
                                                   opt.length));
     opt.free();
     return result;
   }
 
   int accept(int fd) {
     return _retry(() => _accept.icall$3(fd, Foreign.NULL, Foreign.NULL));
   }
 
   int port(int fd) {
     const int LENGTH = 28;
-    var sockaddr = new Foreign.allocated(LENGTH);
-    var addrlen = new Foreign.allocated(4);
+    var sockaddr = new ForeignMemory.allocated(LENGTH);
+    var addrlen = new ForeignMemory.allocated(4);
     addrlen.setInt32(0, LENGTH);
     int status = _retry(() => _getsockname.icall$3(fd, sockaddr, addrlen));
     int port = -1;
     if (status == 0) {
       port = sockaddr.getUint8(2) << 8;
       port |= sockaddr.getUint8(3);
     }
     sockaddr.free();
     addrlen.free();
     return port;
   }
 
   int connect(int fd, _InternetAddress address, int port) {
-    Foreign sockaddr = _createSocketAddress(address, port);
+    ForeignMemory sockaddr = _createSocketAddress(address, port);
     int status = _retry(() => _connect.icall$3(fd, sockaddr, sockaddr.length));
     sockaddr.free();
     return status;
   }
 
   int setBlocking(int fd, bool blocking) {
     int flags = _retry(() => _fcntl.icall$3(fd, F_GETFL, 0));
     if (flags == -1) return -1;
     if (blocking) {
       flags &= ~O_NONBLOCK;
@@ skipping 11 matching lines @@
     Struct result = new Struct(1);
     int status = _retry(() => _ioctl.icall$3(fd, FIONREAD, result));
     int available = result.getWord(0);
     result.free();
     if (status == -1) return status;
     return available;
   }
 
   int read(int fd, var buffer, int offset, int length) {
     _rangeCheck(buffer, offset, length);
-    var address = buffer.getForeign().value + offset;
+    var address = buffer.getForeign().address + offset;
     return _retry(() => _read.icall$3(fd, address, length));
   }
 
   int write(int fd, var buffer, int offset, int length) {
     _rangeCheck(buffer, offset, length);
-    var address = buffer.getForeign().value + offset;
+    var address = buffer.getForeign().address + offset;
     return _retry(() => _write.icall$3(fd, address, length));
   }
 
   void memcpy(var dest,
               int destOffset,
               var src,
               int srcOffset,
               int length) {
-    var destAddress = dest.getForeign().value + destOffset;
-    var srcAddress = src.getForeign().value + srcOffset;
+    var destAddress = dest.getForeign().address + destOffset;
+    var srcAddress = src.getForeign().address + srcOffset;
     _memcpy.icall$3(destAddress, srcAddress, length);
   }
 
   int shutdown(int fd, int how) {
     return _retry(() => _shutdown.icall$2(fd, how));
   }
 
   int close(int fd) {
     return _retry(() => _close.icall$1(fd));
   }
@@ skipping 10 matching lines @@
   Errno errno() {
     return Errno.from(Foreign.errno);
   }
 
   static void _rangeCheck(ByteBuffer buffer, int offset, int length) {
     if (buffer.lengthInBytes < offset + length) {
       throw new IndexError(length, buffer);
     }
   }
 
-  Foreign _createSocketAddress(_InternetAddress address, int port) {
+  ForeignMemory _createSocketAddress(_InternetAddress address, int port) {
     var bytes = address._bytes;
-    Foreign sockaddr;
+    ForeignMemory sockaddr;
     int length;
     if (bytes.length == 4) {
       length = 16;
-      sockaddr = new Foreign.allocated(length);
+      sockaddr = new ForeignMemory.allocated(length);
       sockaddr.setUint16(0, AF_INET);
       sockaddr.copyBytesFromList(bytes, 4, 8, 0);
     } else if (bytes.length == 16) {
       length = 28;
-      sockaddr = new Foreign.allocated(length);
+      sockaddr = new ForeignMemory.allocated(length);
       sockaddr.setUint16(0, AF_INET6);
       sockaddr.copyBytesFromList(bytes, 8, 24, 0);
     } else {
       throw "Invalid InternetAddress";
     }
     // Set port in Network Byte Order.
     sockaddr.setUint8(2, port >> 8);
     sockaddr.setUint8(3, port & 0xFF);
     return sockaddr;
   }
 
   int _retry(Function f) {
     int value;
     while ((value = f()) == -1) {
       if (Foreign.errno != Errno.EINTR) break;
     }
     return value;
   }
 }