add sockets library, use new type_error function from sockets system calls

diff --git a/src/prolog/lib/sockets.pl b/src/prolog/lib/sockets.pl
new file mode 100644 (file)
index 0000000..83ea383
--- /dev/null
+++ b/src/prolog/lib/sockets.pl
@@ -0,0 +1,60 @@
+
+:- module(sockets, [socket_client_open/3,
+                    socket_server_open/2,
+                    socket_server_accept/4,
+                    socket_server_close/1,
+                    current_hostname/1]).
+
+:- use_module(library(error)).
+:- use_module(library(lists)).
+:- use_module(library(pairs)).
+
+
+socket_client_open(Addr, Stream, Options) :-
+    (  var(Addr) ->
+       throw(error(instantiation_error, socket_client_open/3))
+    ;
+       true
+    ),
+    must_be(var, Stream),
+    must_be(list, Options),
+    (  Addr = Address:Port,
+       atom(Address),
+       ( atom(Port) ; integer(Port) ) ->
+       true
+    ;
+       throw(error(type_error(socket_address, Addr), socket_client_open/3))
+    ),
+    builtins:parse_stream_options(Options,
+                                  [Alias, EOFAction, Reposition, Type],
+                                  socket_client_open/3),
+    '$socket_client_open'(Address, Port, Stream, Alias, EOFAction, Reposition, Type).
+
+
+socket_server_open(Addr, ServerSocket) :-
+    must_be(var, ServerSocket),
+    (  ( integer(Addr) ; var(Addr) ) ->
+       '$socket_server_open'([], Addr, ServerSocket)
+    ;
+       Addr = Address:Port,
+       must_be(atom, Address),
+       can_be(integer, Port),
+       '$socket_server_open'(Address, Port, ServerSocket)
+    ).
+
+
+socket_server_accept(ServerSocket, Client, Stream, Options) :-
+    must_be(var, Client),
+    must_be(var, Stream),
+    builtins:parse_stream_options(Options,
+                                  [Alias, EOFAction, Reposition, Type],
+                                  socket_server_accept/4),
+    '$socket_server_accept'(ServerSocket, Client, Stream, Alias, EOFAction, Reposition, Type).
+
+
+socket_server_close(ServerSocket) :-
+    '$socket_server_close'(ServerSocket).
+
+
+current_hostname(HostName) :-
+    '$current_hostname'(HostName).

diff --git a/src/prolog/machine/system_calls.rs b/src/prolog/machine/system_calls.rs
index 5e39322e1eb215041e040684d3921150fd638a85..4e0d2e393d2a2fc1070bb74a4b106983dcbd33df 100644 (file)
--- a/src/prolog/machine/system_calls.rs
+++ b/src/prolog/machine/system_calls.rs
@@ -4112,55 +4112,39 @@ impl MachineState {
                             }
                             culprit => {
                                 let culprit = culprit.as_addr(h);
-                                let stub = MachineError::functor_stub(
-                                    clause_name!("socket_server_close"),
-                                    1,
-                                );
 
-                                let err = MachineError::type_error(
-                                    self.heap.h(),
+                                return Err(self.type_error(
                                     ValidType::TcpListener,
                                     culprit,
-                                );
-
-                                return Err(self.error_form(err, stub));
+                                    clause_name!("socket_server_accept"),
+                                    4,
+                                ));
                             }
                         }
                     }
                     culprit => {
-                        let stub = MachineError::functor_stub(
-                            clause_name!("socket_server_accept"),
-                            4,
-                        );
-
-                        let err = MachineError::type_error(
-                            self.heap.h(),
+                        return Err(self.type_error(
                             ValidType::TcpListener,
                             culprit,
-                        );
-
-                        return Err(self.error_form(err, stub));
+                            clause_name!("socket_server_accept"),
+                            4,
+                        ));
                     }
                 }
             }
             &SystemClauseType::SocketServerClose => {
                 match self.store(self.deref(self[temp_v!(1)])) {
                     Addr::TcpListener(h) => {
-                        self.heap[h] = HeapCellValue::Addr(Addr::EmptyList);
+                        let closed_tcp_listener = clause_name!("$closed_tcp_listener");
+                        self.heap[h] = HeapCellValue::Atom(closed_tcp_listener, None);
                     }
                     culprit => {
-                        let stub = MachineError::functor_stub(
-                            clause_name!("socket_server_close"),
-                            1,
-                        );
-
-                        let err = MachineError::type_error(
-                            self.heap.h(),
+                        return Err(self.type_error(
                             ValidType::TcpListener,
                             culprit,
-                        );
-
-                        return Err(self.error_form(err, stub));
+                            clause_name!("socket_server_close"),
+                            1,
+                        ));
                     }
                 }
             }