From 21399dca12a7bd812b89d359e2d838965c25f17d Mon Sep 17 00:00:00 2001 From: Tim Chevalier Date: Fri, 22 Jun 2012 11:53:25 -0700 Subject: [PATCH] Change resources to classes in libstd and rustc --- src/libstd/c_vec.rs | 8 +++- src/libstd/net_tcp.rs | 73 ++++++++++++++++++-------------- src/rustc/driver/rustc.rs | 6 ++- src/rustc/lib/llvm.rs | 24 +++++++---- src/rustc/middle/trans/base.rs | 12 ++++-- src/rustc/middle/trans/build.rs | 2 +- src/rustc/middle/trans/common.rs | 6 ++- src/rustc/util/common.rs | 6 ++- 8 files changed, 85 insertions(+), 52 deletions(-) diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index 57fff2cdcbd3..3c89adfb1aae 100644 --- a/src/libstd/c_vec.rs +++ b/src/libstd/c_vec.rs @@ -41,11 +41,15 @@ enum c_vec { c_vec_({ base: *mut T, len: uint, rsrc: @dtor_res}) } -resource dtor_res(dtor: option) { - alt dtor { +class dtor_res { + let dtor: option; + new(dtor: option) { self.dtor = dtor; } + drop { + alt self.dtor { option::none { } option::some(f) { f(); } } + } } /* diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index a2d36ac354b8..5e116cd11cfd 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -35,33 +35,41 @@ Encapsulates an open TCP/IP connection through libuv underlying libuv data structures when it goes out of scope. This is the data structure that is used for read/write operations over a TCP stream. "] -resource tcp_socket(socket_data: @tcp_socket_data) +class tcp_socket { + let socket_data: @tcp_socket_data; + new(socket_data: @tcp_socket_data) { self.socket_data = socket_data; } + drop { unsafe { - let closed_po = comm::port::<()>(); - let closed_ch = comm::chan(closed_po); - let close_data = { - closed_ch: closed_ch - }; - let close_data_ptr = ptr::addr_of(close_data); - let stream_handle_ptr = (*socket_data).stream_handle_ptr; - iotask::interact((*socket_data).iotask) {|loop_ptr| - log(debug, #fmt("interact dtor for tcp_socket stream %? loop %?", + let closed_po = comm::port::<()>(); + let closed_ch = comm::chan(closed_po); + let close_data = { + closed_ch: closed_ch + }; + let close_data_ptr = ptr::addr_of(close_data); + let stream_handle_ptr = (*(self.socket_data)).stream_handle_ptr; + iotask::interact((*(self.socket_data)).iotask) {|loop_ptr| + log(debug, #fmt("interact dtor for tcp_socket stream %? loop %?", stream_handle_ptr, loop_ptr)); - uv::ll::set_data_for_uv_handle(stream_handle_ptr, + uv::ll::set_data_for_uv_handle(stream_handle_ptr, close_data_ptr); - uv::ll::close(stream_handle_ptr, tcp_socket_dtor_close_cb); - }; - comm::recv(closed_po); - log(debug, #fmt("about to free socket_data at %?", socket_data)); - rustrt::rust_uv_current_kernel_free(stream_handle_ptr - as *libc::c_void); - log(debug, "exiting dtor for tcp_socket"); + uv::ll::close(stream_handle_ptr, tcp_socket_dtor_close_cb); + }; + comm::recv(closed_po); + log(debug, #fmt("about to free socket_data at %?", self.socket_data)); + rustrt::rust_uv_current_kernel_free(stream_handle_ptr + as *libc::c_void); + log(debug, "exiting dtor for tcp_socket"); + } + } } -resource tcp_conn_port(conn_data: @tcp_conn_port_data) unsafe { - let conn_data_ptr = ptr::addr_of(*conn_data); +class tcp_conn_port { + let conn_data: @tcp_conn_port_data; + new(conn_data: @tcp_conn_port_data) { self.conn_data = conn_data; } + drop unsafe { + let conn_data_ptr = ptr::addr_of(*(self.conn_data)); let server_stream_ptr = ptr::addr_of((*conn_data_ptr).server_stream); - let stream_closed_po = (*conn_data).stream_closed_po; + let stream_closed_po = (*(self.conn_data)).stream_closed_po; let iotask = (*conn_data_ptr).iotask; iotask::interact(iotask) {|loop_ptr| log(debug, #fmt("dtor for tcp_conn_port loop: %?", @@ -69,6 +77,7 @@ resource tcp_conn_port(conn_data: @tcp_conn_port_data) unsafe { uv::ll::close(server_stream_ptr, tcp_nl_close_cb); } comm::recv(stream_closed_po); + } } #[doc=" @@ -207,7 +216,7 @@ value as the `err` variant "] fn write(sock: tcp_socket, raw_write_data: [u8]) -> result::result<(), tcp_err_data> unsafe { - let socket_data_ptr = ptr::addr_of(**sock); + let socket_data_ptr = ptr::addr_of(*(sock.socket_data)); write_common_impl(socket_data_ptr, raw_write_data) } @@ -240,7 +249,7 @@ value as the `err` variant "] fn write_future(sock: tcp_socket, raw_write_data: [u8]) -> future::future> unsafe { - let socket_data_ptr = ptr::addr_of(**sock); + let socket_data_ptr = ptr::addr_of(*(sock.socket_data)); future::spawn {|| write_common_impl(socket_data_ptr, raw_write_data) } @@ -262,7 +271,7 @@ on) from until `read_stop` is called, or a `tcp_err_data` record fn read_start(sock: tcp_socket) -> result::result>, tcp_err_data> unsafe { - let socket_data = ptr::addr_of(**sock); + let socket_data = ptr::addr_of(*(sock.socket_data)); read_start_common_impl(socket_data) } @@ -275,7 +284,7 @@ Stop reading from an open TCP connection; used with `read_start` "] fn read_stop(sock: tcp_socket) -> result::result<(), tcp_err_data> unsafe { - let socket_data = ptr::addr_of(**sock); + let socket_data = ptr::addr_of(*(sock.socket_data)); read_stop_common_impl(socket_data) } @@ -295,7 +304,7 @@ read attempt. Pass `0u` to wait indefinitely "] fn read(sock: tcp_socket, timeout_msecs: uint) -> result::result<[u8],tcp_err_data> { - let socket_data = ptr::addr_of(**sock); + let socket_data = ptr::addr_of(*(sock.socket_data)); read_common_impl(socket_data, timeout_msecs) } @@ -329,7 +338,7 @@ read attempt. Pass `0u` to wait indefinitely "] fn read_future(sock: tcp_socket, timeout_msecs: uint) -> future::future> { - let socket_data = ptr::addr_of(**sock); + let socket_data = ptr::addr_of(*(sock.socket_data)); future::spawn {|| read_common_impl(socket_data, timeout_msecs) } @@ -444,8 +453,8 @@ variant "] fn conn_recv(server_port: tcp_conn_port) -> result::result { - let new_conn_po = (**server_port).new_conn_po; - let iotask = (**server_port).iotask; + let new_conn_po = (*(server_port.conn_data)).new_conn_po; + let iotask = (*(server_port.conn_data)).iotask; let new_conn_result = comm::recv(new_conn_po); alt new_conn_result { ok(client_stream_ptr) { @@ -475,8 +484,8 @@ once a new connection is recv'd. Its parameter: "] fn conn_recv_spawn(server_port: tcp_conn_port, +cb: fn~(result::result)) { - let new_conn_po = (**server_port).new_conn_po; - let iotask = (**server_port).iotask; + let new_conn_po = (*(server_port.conn_data)).new_conn_po; + let iotask = (*(server_port.conn_data)).iotask; let new_conn_result = comm::recv(new_conn_po); task::spawn {|| let sock_create_result = alt new_conn_result { @@ -507,7 +516,7 @@ connection none. "] fn conn_peek(server_port: tcp_conn_port) -> bool { - let new_conn_po = (**server_port).new_conn_po; + let new_conn_po = (*(server_port.conn_data)).new_conn_po; comm::peek(new_conn_po) } diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs index bc88609d274f..634d5587f175 100644 --- a/src/rustc/driver/rustc.rs +++ b/src/rustc/driver/rustc.rs @@ -223,8 +223,10 @@ fn monitor(+f: fn~(diagnostic::emitter)) { diagnostic::emit(cmsp, msg, lvl); }; - resource finally(ch: comm::chan) { - comm::send(ch, done); + class finally { + let ch: comm::chan; + new(ch: comm::chan) { self.ch = ch; } + drop { comm::send(self.ch, done); } } let _finally = finally(ch); diff --git a/src/rustc/lib/llvm.rs b/src/rustc/lib/llvm.rs index 4e4f9829dfbc..1c5d41b0939c 100644 --- a/src/rustc/lib/llvm.rs +++ b/src/rustc/lib/llvm.rs @@ -1092,8 +1092,10 @@ fn fn_ty_param_tys(fn_ty: TypeRef) -> [TypeRef] unsafe { /* Memory-managed interface to target data. */ -resource target_data_res(TD: TargetDataRef) { - llvm::LLVMDisposeTargetData(TD); +class target_data_res { + let TD: TargetDataRef; + new(TD: TargetDataRef) { self.TD = TD; } + drop { llvm::LLVMDisposeTargetData(self.TD); } } type target_data = {lltd: TargetDataRef, dtor: @target_data_res}; @@ -1106,8 +1108,10 @@ fn mk_target_data(string_rep: str) -> target_data { /* Memory-managed interface to pass managers. */ -resource pass_manager_res(PM: PassManagerRef) { - llvm::LLVMDisposePassManager(PM); +class pass_manager_res { + let PM: PassManagerRef; + new(PM: PassManagerRef) { self.PM = PM; } + drop { llvm::LLVMDisposePassManager(self.PM); } } type pass_manager = {llpm: PassManagerRef, dtor: @pass_manager_res}; @@ -1119,8 +1123,10 @@ fn mk_pass_manager() -> pass_manager { /* Memory-managed interface to object files. */ -resource object_file_res(ObjectFile: ObjectFileRef) { - llvm::LLVMDisposeObjectFile(ObjectFile); +class object_file_res { + let ObjectFile: ObjectFileRef; + new(ObjectFile: ObjectFileRef) { self.ObjectFile = ObjectFile; } + drop { llvm::LLVMDisposeObjectFile(self.ObjectFile); } } type object_file = {llof: ObjectFileRef, dtor: @object_file_res}; @@ -1133,8 +1139,10 @@ fn mk_object_file(llmb: MemoryBufferRef) -> option { /* Memory-managed interface to section iterators. */ -resource section_iter_res(SI: SectionIteratorRef) { - llvm::LLVMDisposeSectionIterator(SI); +class section_iter_res { + let SI: SectionIteratorRef; + new(SI: SectionIteratorRef) { self.SI = SI; } + drop { llvm::LLVMDisposeSectionIterator(self.SI); } } type section_iter = {llsi: SectionIteratorRef, dtor: @section_iter_res}; diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs index d202ba7a123f..dc4e681dc162 100644 --- a/src/rustc/middle/trans/base.rs +++ b/src/rustc/middle/trans/base.rs @@ -88,9 +88,13 @@ fn dup_for_join(dest: dest) -> dest { } } -resource icx_popper(ccx: @crate_ctxt) { - if ccx.sess.count_llvm_insns() { - vec::pop(*ccx.stats.llvm_insn_ctxt); +class icx_popper { + let ccx: @crate_ctxt; + new(ccx: @crate_ctxt) { self.ccx = ccx; } + drop { + if self.ccx.sess.count_llvm_insns() { + vec::pop(*(self.ccx.stats.llvm_insn_ctxt)); + } } } @@ -5186,7 +5190,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef, let llbb = str::as_c_str("top", {|buf| llvm::LLVMAppendBasicBlock(llfn, buf) }); - let bld = *ccx.builder; + let bld = ccx.builder.B; llvm::LLVMPositionBuilderAtEnd(bld, llbb); let crate_map = ccx.crate_map; let start_ty = T_fn([val_ty(rust_main), ccx.int_type, ccx.int_type, diff --git a/src/rustc/middle/trans/build.rs b/src/rustc/middle/trans/build.rs index cbc07ce6d287..6932dbda0bbe 100644 --- a/src/rustc/middle/trans/build.rs +++ b/src/rustc/middle/trans/build.rs @@ -10,7 +10,7 @@ import common::*; import driver::session::session; fn B(cx: block) -> BuilderRef { - let b = *cx.fcx.ccx.builder; + let b = cx.fcx.ccx.builder.B; llvm::LLVMPositionBuilderAtEnd(b, cx.llbb); ret b; } diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs index d3f75d3c07db..8c0abd5166e2 100644 --- a/src/rustc/middle/trans/common.rs +++ b/src/rustc/middle/trans/common.rs @@ -62,7 +62,11 @@ type stats = llvm_insns: hashmap, fn_times: @mut [{ident: str, time: int}]}; -resource BuilderRef_res(B: BuilderRef) { llvm::LLVMDisposeBuilder(B); } +class BuilderRef_res { + let B: BuilderRef; + new(B: BuilderRef) { self.B = B; } + drop { llvm::LLVMDisposeBuilder(self.B); } +} // Crate context. Every crate we compile has one of these. type crate_ctxt = { diff --git a/src/rustc/util/common.rs b/src/rustc/util/common.rs index 6e6c5fa740e5..381b5ce6a823 100644 --- a/src/rustc/util/common.rs +++ b/src/rustc/util/common.rs @@ -14,8 +14,10 @@ fn indent(op: fn() -> R) -> R { ret r; } -resource _indenter(_i: ()) { - #debug["<<"]; +class _indenter { + let _i: (); + new(_i: ()) { self._i = (); } + drop { #debug["<<"]; } } fn indenter() -> _indenter {