global: Completly disable inlining

This is because it looks more, and more clear that the entire codebase
was compiled without inlining. Likely to reduce code size from all the
byteswap functions, only present on the GameCube version.

1 files changed, 64 insertions, 64 deletions

diff --git a/src/pso/TTcpSocket.cpp b/src/pso/TTcpSocket.cpp
index 949f962..55bf360 100644
--- a/src/pso/TTcpSocket.cpp
+++ b/src/pso/TTcpSocket.cpp
@@ -66,10 +66,10 @@ TTcpSocket::~TTcpSocket() {
 }
 
 void TTcpSocket::recv() {
-	if (sock_fd() != -1) {
-		packet_buffer().fill(0);
-		set_buffer_cleared(true);
-		(int)tcp_receive(sock_fd(), notify, packet_buffer().size(), packet_buffer().data());
+	if (m_sock_fd != -1) {
+		memset(m_packet_buffer, 0, sizeof(m_packet_buffer));
+		m_buffer_cleared = true;
+		(int)tcp_receive(m_sock_fd, notify, sizeof(m_packet_buffer), m_packet_buffer);
 	}
 }
 
@@ -79,49 +79,49 @@ void TTcpSocket::notify(short size, short sock_fd) {
 
 	if (socket != nullptr) {
 		if (size > 0) {
-			socket->set_buffer_cleared(false);
-			socket->set_size(size);
-			socket->set_buffer_offset(0);
+			socket->m_buffer_cleared = false;
+			socket->m_size = size;
+			socket->m_buffer_offset = 0;
 			sprintf(tmp_str, "Rcv:%d byte", size);
 			socket->log(tmp_str);
-			if (socket->callback() != nullptr) {
-				socket->callback()(socket);
+			if (socket->m_callback != nullptr) {
+				socket->m_callback(socket);
 			}
 		} else {
-			socket->set_flags(1);
+			socket->m_is_invalid_packet |= 1;
 		}
 	}
 }
 
 short TTcpSocket::send(u8 *data, size_t size) {
-	if (sock_fd() != -1) {
+	if (m_sock_fd != -1) {
 		if (!m_is_encrypted) {
 			m_send_crypt.encrypt(data, size);
 		}
 
-		if (is_invalid_packet() || !get_link_status()) {
+		if (m_is_invalid_packet || !get_link_status()) {
 			return -1;
 		} else {
 			if (int status = stat()) {
 				log(get_sock_status_name(status));
-				set_flags(1);
+				m_is_invalid_packet |= 1;
 				return 1;
 			} else {
-				if (send_window() <= size) {
-					set_flags(1);
+				if (m_send_window <= size) {
+					m_is_invalid_packet |= 1;
 					return 1;
 				} else {
-					if (stat_val() < 0) {
-						set_flags(1);
+					if (m_stat_val < 0) {
+						m_is_invalid_packet |= 1;
 						return 1;
 					} else {
 						struct send_buffs sb;
 						sb.buff = data;
 						sb.len = size;
-						set_unused(0);
-						int ret = tcp_send(sock_fd(), nullptr, 1, &sb);
+						m_unused = 0;
+						int ret = tcp_send(m_sock_fd, nullptr, 1, &sb);
 						if (ret >= 1 || ret < -1) {
-							set_flags(1);
+							m_is_invalid_packet |= 1;
 							log(get_sock_status_name(ret));
 							close();
 							return ret;
@@ -136,28 +136,28 @@ short TTcpSocket::send(u8 *data, size_t size) {
 }
 
 short TTcpSocket::send(u8 *data) {
-	if (sock_fd() != -1) {
-		if (is_invalid_packet() || !get_link_status()) {
+	if (m_sock_fd != -1) {
+		if (m_is_invalid_packet || !get_link_status()) {
 			return -1;
 		} else {
 			if (short status = stat()) {
 				log(get_sock_status_name(status));
-				set_flags(1);
+				m_is_invalid_packet |= 1;
 				return 1;
 			} else {
-				if (stat_val() < 0) {
-					set_flags(1);
+				if (m_stat_val < 0) {
+					m_is_invalid_packet |= 1;
 					return 1;
 				} else {
 					s8 len = strlen(reinterpret_cast<const char *>(data));
 					struct send_buffs sb;
 					sb.buff = data;
 					sb.len = len;
-					if (send_window() <= len) {
-						set_flags(1);
+					if (m_send_window <= len) {
+						m_is_invalid_packet |= 1;
 						return 1;
 					} else {
-						short ret = tcp_send(sock_fd(), nullptr, 1, &sb);
+						short ret = tcp_send(m_sock_fd, nullptr, 1, &sb);
 						if (ret) {
 							close();
 						}
@@ -175,18 +175,18 @@ int TTcpSocket::test_connection() {
 	for (int i = 0; i < 1800; ++i) {
 		if (int status = stat()) {
 			log(get_sock_status_name(status));
-			set_flags(1);
+			m_is_invalid_packet |= 1;
 			return 1;
-		} else if (send_window() <= 128) {
-			set_flags(1);
+		} else if (m_send_window <= 128) {
+			m_is_invalid_packet |= 1;
 			return 1;
-		} else if (stat_val() < 0) {
-			set_flags(1);
+		} else if (m_stat_val < 0) {
+			m_is_invalid_packet |= 1;
 			return 1;
 		} else if (!get_link_status()) {
-			set_flags(1);
+			m_is_invalid_packet |= 1;
 			return 1;
-		} else if (send_window() > 4095) {
+		} else if (m_send_window > 4095) {
 			return 0;
 		} else {
 			main_task.some_empty_func();
@@ -198,45 +198,45 @@ int TTcpSocket::test_connection() {
 		}
 	}
 
-	set_flags(1);
+	m_is_invalid_packet |= 1;
 	return 1;
 }
 
 void TTcpSocket::some_stub() {}
 
 short TTcpSocket::stat() {
-	if (sock_fd() != -1) {
-		return tcp_stat(sock_fd(), &stat_val(), nullptr, &send_window(), &recv_window());
+	if (m_sock_fd != -1) {
+		return tcp_stat(m_sock_fd, &m_stat_val, nullptr, &m_send_window, &m_recv_window);
 	} else {
 		return 0;
 	}
 }
 
 short TTcpSocket::close() {
-	if (sock_fd() != -1) {
-		(short)tcp_abort(sock_fd());
-		(short)tcp_delete(sock_fd());
-		tcp_socket_table[sock_fd()] = nullptr;
-		set_sock_fd(-1);
+	if (m_sock_fd != -1) {
+		(short)tcp_abort(m_sock_fd);
+		(short)tcp_delete(m_sock_fd);
+		tcp_socket_table[m_sock_fd] = nullptr;
+		m_sock_fd = -1;
 		m_is_encrypted = 0;
-		set_size(0);
-		set_buffer_offset(0);
-		set_buffer_cleared(true);
+		m_size = 0;
+		m_buffer_offset = 0;
+		m_buffer_cleared = true;
 	}
-	return sock_fd();
+	return m_sock_fd;
 }
 
 short TTcpSocket::open() {
-	set_sock_fd(-1);
+	m_sock_fd = -1;
 	m_is_encrypted = 0;
-	set_size(0);
-	set_buffer_offset(0);
-	set_buffer_cleared(true);
-	set_unused(0);
-	set_sock_fd(tcp_create());
+	m_size = 0;
+	m_buffer_offset = 0;
+	m_buffer_cleared = true;
+	m_unused = 0;
+	m_sock_fd = tcp_create();
 
-	if (sock_fd() < 0) {
-		log(get_sock_status_name(sock_fd()));
+	if (m_sock_fd < 0) {
+		log(get_sock_status_name(m_sock_fd));
 		return -1;
 	} else {
 		struct at_ip_option connect_option;
@@ -245,23 +245,23 @@ short TTcpSocket::open() {
 
 		u32 opt = 1;
 
-		tcp_get_opt(sock_fd(), 0x2001, &opt);
+		tcp_get_opt(m_sock_fd, 0x2001, &opt);
 
 		bind_addr.type = 4;
 		bind_addr.ip46.ip4 = 0;
 
-		tcp_bind(sock_fd(), &bind_addr, src_port());
+		tcp_bind(m_sock_fd, &bind_addr, m_src_port);
 
 		connect_addr.type = 4;
-		connect_addr.ip46.ip4 = dst_addr().addr;
+		connect_addr.ip46.ip4 = m_dst_addr.addr;
 
 		connect_option.type = 4;
 		connect_option.ip46.ip4.ttl = 120;
 		connect_option.ip46.ip4.svctype = 0;
 		connect_option.ip46.ip4.df_flag = 0;
 
-		if (tcp_connect(sock_fd(), &connect_addr, dst_port(), &connect_option)) {
-			log(get_sock_status_name(sock_fd()));
+		if (tcp_connect(m_sock_fd, &connect_addr, m_dst_port, &connect_option)) {
+			log(get_sock_status_name(m_sock_fd));
 			return -1;
 		} else {
 			for (;;) {
@@ -270,11 +270,11 @@ short TTcpSocket::open() {
 				if (short status = stat()) {
 					log(get_sock_status_name(status));
 					return -2;
-				} else if (stat_val() < 0) {
+				} else if (m_stat_val < 0) {
 					return -2;
 				} else {
 					some_stub();
-					if (stat_val() < 4) {
+					if (m_stat_val < 4) {
 						if (!get_link_status()) {
 							return -3;
 						} else if (func_801a5d1c()) {
@@ -288,8 +288,8 @@ short TTcpSocket::open() {
 							render_tick();
 						}
 					} else {
-						tcp_socket_table[sock_fd()] = this;
-						return sock_fd();
+						tcp_socket_table[m_sock_fd] = this;
+						return m_sock_fd;
 					}
 				}
 			}