Cellular: Updated coding guidelines

Author: Ari Parkkila

features/cellular/TESTS/socket/udp/main.cpp

@@ -71,7 +71,7 @@ void trace_release()
 
 static char time_st[sizeof("[12345678]") + 1];
 
-static char* trace_time(size_t ss)
+static char *trace_time(size_t ss)
 {
     snprintf(time_st, sizeof("[12345678]"), "[%08llu]", rtos::Kernel::get_ms_count());
     return time_st;
@@ -80,7 +80,7 @@ static char* trace_time(size_t ss)
 static void trace_open()
 {
     mbed_trace_init();
-    mbed_trace_prefix_function_set( &trace_time );
+    mbed_trace_prefix_function_set(&trace_time);
     mbed_trace_mutex_wait_function_set(trace_wait);
     mbed_trace_mutex_release_function_set(trace_release);
 
@@ -104,85 +104,92 @@ static rtos::EventFlags eventFlags;
 
 class EchoSocket : public UDPSocket {
 public:
-  EchoSocket(int size) : UDPSocket(), _data(0), _size(size), _async_flag(0), _tx_pending(false), _rx_pending(false) {
-  }
-  virtual ~EchoSocket() {
-    delete _data;
-  }
-  void set_async(int async) {
-      _async_flag = async;
+    EchoSocket(int size) : UDPSocket(), _data(0), _size(size), _async_flag(0), _tx_pending(false), _rx_pending(false)
+    {
+    }
+    virtual ~EchoSocket()
+    {
+        delete _data;
+    }
+    void set_async(int async)
+    {
+        _async_flag = async;
         if (_async_flag) {
             set_blocking(false);
             sigio(callback(this, &EchoSocket::async_callback));
         }
-	}
-
-	void test_sendto(const char *const hostname = NULL) {
-	    if (!_data) {
-	        _data = new uint8_t[_size];
-	        for (int i=0; i<_size; i++) {
-	            _data[i] = (uint8_t)rand();
-	        }
-	    }
-	    nsapi_size_or_error_t ret;
-		if (hostname) {
-		    ret = sendto(hostname, ECHO_SERVER_UDP_PORT, _data, _size);
-		} else {
-		    ret = sendto(echo_server_addr, _data, _size);
-		}
-		if (ret == _size) { // send successful
-		    _tx_pending = false;
-		} else {
-		    TEST_ASSERT(_async_flag && ret == NSAPI_ERROR_WOULD_BLOCK);
+    }
+
+    void test_sendto(const char *const hostname = NULL)
+    {
+        if (!_data) {
+            _data = new uint8_t[_size];
+            for (int i = 0; i < _size; i++) {
+                _data[i] = (uint8_t)rand();
+            }
+        }
+        nsapi_size_or_error_t ret;
+        if (hostname) {
+            ret = sendto(hostname, ECHO_SERVER_UDP_PORT, _data, _size);
+        } else {
+            ret = sendto(echo_server_addr, _data, _size);
+        }
+        if (ret == _size) { // send successful
+            _tx_pending = false;
+        } else {
+            TEST_ASSERT(_async_flag && ret == NSAPI_ERROR_WOULD_BLOCK);
             _tx_pending = true;
-		}
-	}
-
-	void test_recvfrom() {
-		uint8_t *buf = new uint8_t[_size];
-		memset(buf, 0, _size);
-		SocketAddress recv_address;
-		nsapi_size_or_error_t ret = recvfrom(&recv_address, buf, _size);
-		if (ret == _size) { // recv successful
-		    _rx_pending = false;
-	        TEST_ASSERT(recv_address == echo_server_addr);
-	        TEST_ASSERT(memcmp(_data, buf, _size) == 0);
-	        delete _data;
-	        _data = NULL;
-	        _rx_pending = false;
-		} else {
-		    TEST_ASSERT(_async_flag && ret == NSAPI_ERROR_WOULD_BLOCK);
+        }
+    }
+
+    void test_recvfrom()
+    {
+        uint8_t *buf = new uint8_t[_size];
+        memset(buf, 0, _size);
+        SocketAddress recv_address;
+        nsapi_size_or_error_t ret = recvfrom(&recv_address, buf, _size);
+        if (ret == _size) { // recv successful
+            _rx_pending = false;
+            TEST_ASSERT(recv_address == echo_server_addr);
+            TEST_ASSERT(memcmp(_data, buf, _size) == 0);
+            delete _data;
+            _data = NULL;
+            _rx_pending = false;
+        } else {
+            TEST_ASSERT(_async_flag && ret == NSAPI_ERROR_WOULD_BLOCK);
             _rx_pending = true;
-		}
+        }
         delete buf;
-	}
+    }
 
-	bool async_process() {
+    bool async_process()
+    {
         if (_tx_pending) {
             test_sendto();
         }
         if (_rx_pending) {
             test_recvfrom();
         }
         return _tx_pending | _rx_pending;
-	}
+    }
 
 private:
-	void async_callback() {
-	    eventFlags.set(_async_flag);
-	}
-	uint8_t *_data;
-	int _size;
-	uint32_t _async_flag; // 0 for blocking socket, signal bit for async
-	bool _tx_pending;
-	bool _rx_pending;
+    void async_callback()
+    {
+        eventFlags.set(_async_flag);
+    }
+    uint8_t *_data;
+    int _size;
+    uint32_t _async_flag; // 0 for blocking socket, signal bit for async
+    bool _tx_pending;
+    bool _rx_pending;
 };
 
 static void network_callback(nsapi_event_t ev, intptr_t ptr)
 {
     if (ev == NSAPI_EVENT_CONNECTION_STATUS_CHANGE) {
         if (ptr == NSAPI_STATUS_GLOBAL_UP) {
-        	MBED_ASSERT(network_semaphore.release() == osOK);
+            MBED_ASSERT(network_semaphore.release() == osOK);
         }
     }
 }
@@ -192,25 +199,25 @@ static void udp_network_stack()
     cellular.set_serial(&cellular_serial);
     TEST_ASSERT(cellular.init() == NSAPI_ERROR_OK);
 #if defined (MDMRTS) && defined (MDMCTS)
-	cellular_serial.set_flow_control(SerialBase::RTSCTS, MDMRTS, MDMCTS);
+    cellular_serial.set_flow_control(SerialBase::RTSCTS, MDMRTS, MDMCTS);
 #endif
     cellular.attach(&network_callback);
     TEST_ASSERT(cellular.start_dispatch() == NSAPI_ERROR_OK);
     cellular.set_sim_pin(MBED_CONF_APP_CELLULAR_SIM_PIN);
 #ifdef MBED_CONF_APP_APN
-    CellularNetwork * network = cellular.get_network();
+    CellularNetwork *network = cellular.get_network();
     TEST_ASSERT(network->set_credentials(MBED_CONF_APP_APN) == NSAPI_ERROR_OK);
 #endif
     cellular_target_state = CellularConnectionFSM::STATE_CONNECTED;
     TEST_ASSERT(cellular.continue_to_state(cellular_target_state) == NSAPI_ERROR_OK);
-	TEST_ASSERT(network_semaphore.wait(NETWORK_TIMEOUT) == 1);
+    TEST_ASSERT(network_semaphore.wait(NETWORK_TIMEOUT) == 1);
 }
 
 static void udp_gethostbyname()
 {
     TEST_ASSERT(cellular.get_network()->gethostbyname(ECHO_SERVER_NAME, &echo_server_addr) == 0);
     tr_info("Echo server IP: %s", echo_server_addr.get_ip_address());
-	echo_server_addr.set_port(7);
+    echo_server_addr.set_port(7);
 }
 
 static void udp_socket_send_receive()
@@ -250,21 +257,21 @@ static utest::v1::status_t greentea_failure_handler(const Case *const source, co
 {
 #if MBED_CONF_MBED_TRACE_ENABLE
     trace_close();
-#endif 
+#endif
     greentea_case_failure_abort_handler(source, reason);
     return STATUS_ABORT;
 }
 
 static Case cases[] = {
-	Case("UDP network stack", udp_network_stack, greentea_failure_handler),
-	Case("UDP gethostbyname", udp_gethostbyname, greentea_failure_handler),
-	Case("UDP socket send/receive", udp_socket_send_receive, greentea_failure_handler),
-	Case("UDP socket send/receive async", udp_socket_send_receive_async, greentea_failure_handler),
+    Case("UDP network stack", udp_network_stack, greentea_failure_handler),
+    Case("UDP gethostbyname", udp_gethostbyname, greentea_failure_handler),
+    Case("UDP socket send/receive", udp_socket_send_receive, greentea_failure_handler),
+    Case("UDP socket send/receive async", udp_socket_send_receive_async, greentea_failure_handler),
 };
 
 static utest::v1::status_t test_setup(const size_t number_of_cases)
 {
-    GREENTEA_SETUP(10*60, "default_auto"); // network registration may take up to 180 seconds, DNS query a couple of minutes, etc.
+    GREENTEA_SETUP(10 * 60, "default_auto"); // network registration may take up to 180 seconds, DNS query a couple of minutes, etc.
     return verbose_test_setup_handler(number_of_cases);
 }
 
@@ -278,6 +285,6 @@ int main()
     int ret = Harness::run(specification);
 #if MBED_CONF_MBED_TRACE_ENABLE
     trace_close();
-#endif 
-	return ret;
+#endif
+    return ret;
 }

features/cellular/framework/AT/ATHandler.cpp

@@ -265,7 +265,7 @@ void ATHandler::set_at_timeout(uint32_t timeout_milliseconds, bool default_timeo
 void ATHandler::restore_at_timeout()
 {
     if (_previous_at_timeout != _at_timeout) {
-        _at_timeout =_previous_at_timeout;
+        _at_timeout = _previous_at_timeout;
     }
 }
 
@@ -332,7 +332,7 @@ int ATHandler::poll_timeout(bool wait_for_timeout)
         uint64_t now = rtos::Kernel::get_ms_count();
         if (now >= _start_time + _at_timeout) {
             timeout = 0;
-        } else if ( _start_time + _at_timeout - now > INT_MAX) {
+        } else if (_start_time + _at_timeout - now > INT_MAX) {
             timeout = INT_MAX;
         } else {
             timeout = _start_time + _at_timeout - now;
@@ -455,7 +455,7 @@ ssize_t ATHandler::read(char *buf, size_t size, bool read_even_stop_tag, bool he
     }
 
     size_t match_pos = 0;
-    size_t read_size = hex ? size*2 : size;
+    size_t read_size = hex ? size * 2 : size;
 
     consume_char('\"');
 
@@ -465,7 +465,7 @@ ssize_t ATHandler::read(char *buf, size_t size, bool read_even_stop_tag, bool he
 
     for (; read_idx < (read_size + match_pos); read_idx++) {
         int c = get_char();
-        buf_idx = hex ? read_idx/2 : read_idx;
+        buf_idx = hex ? read_idx / 2 : read_idx;
         if (c == -1) {
             buf[buf_idx] = '\0';
             set_error(NSAPI_ERROR_DEVICE_ERROR);
@@ -496,7 +496,7 @@ ssize_t ATHandler::read(char *buf, size_t size, bool read_even_stop_tag, bool he
         } else {
             hexbuf[read_idx % 2] = c;
             if (read_idx % 2 == 1) {
-                hex_str_to_char_str(hexbuf, 2, buf+buf_idx);
+                hex_str_to_char_str(hexbuf, 2, buf + buf_idx);
             }
         }
     }
@@ -540,7 +540,7 @@ void ATHandler::set_default_delimiter()
     _delimiter = DEFAULT_DELIMITER;
 }
 
-void ATHandler::set_tag(tag_t* tag_dst, const char *tag_seq)
+void ATHandler::set_tag(tag_t *tag_dst, const char *tag_seq)
 {
     if (tag_seq) {
         size_t tag_len = strlen(tag_seq);
@@ -589,7 +589,7 @@ void ATHandler::set_scope(ScopeType scope_type)
 }
 
 // should match from recv_pos?
-bool ATHandler::match(const char* str, size_t size)
+bool ATHandler::match(const char *str, size_t size)
 {
     rewind_buffer();
 
@@ -685,7 +685,7 @@ void ATHandler::set_3gpp_error(int err, DeviceErrorType error_type)
         // CMS errors 0-127 maps straight to 3GPP errors
         _last_3gpp_error = err;
     } else {
-        for (size_t i = 0; i<sizeof(map_3gpp_errors)/sizeof(map_3gpp_errors[0]); i++) {
+        for (size_t i = 0; i < sizeof(map_3gpp_errors) / sizeof(map_3gpp_errors[0]); i++) {
             if (map_3gpp_errors[i][0] == err) {
                 _last_3gpp_error = map_3gpp_errors[i][1];
                 tr_debug("AT3GPP error code %d", get_3gpp_error());
@@ -754,7 +754,7 @@ void ATHandler::resp(const char *prefix, bool check_urc)
         } else {
             // If no prefix, no CRLF and no more chance to match for OK, ERROR or URC(since max resp length is already in buffer)
             // return so data could be read
-            if (!prefix && ((_recv_len-_recv_pos) >= _max_resp_length)) {
+            if (!prefix && ((_recv_len - _recv_pos) >= _max_resp_length)) {
                 return;
             }
             if (!fill_buffer()) {
@@ -892,7 +892,7 @@ bool ATHandler::consume_to_stop_tag()
         return true;
     }
 
-    if (consume_to_tag((const char*)_stop_tag->tag, true)) {
+    if (consume_to_tag((const char *)_stop_tag->tag, true)) {
         return true;
     }
 
@@ -954,19 +954,19 @@ void ATHandler::set_string(char *dest, const char *src, size_t src_len)
     dest[src_len] = '\0';
 }
 
-const char* ATHandler::mem_str(const char* dest, size_t dest_len, const char* src, size_t src_len)
+const char *ATHandler::mem_str(const char *dest, size_t dest_len, const char *src, size_t src_len)
 {
     if (dest_len > src_len) {
-        for(size_t i = 0; i < dest_len-src_len+1; ++i) {
-            if(memcmp(dest+i, src, src_len) == 0) {
-                return dest+i;
+        for(size_t i = 0; i < dest_len - src_len + 1; ++i) {
+            if(memcmp(dest + i, src, src_len) == 0) {
+                return dest + i;
             }
         }
     }
     return NULL;
 }
 
-void ATHandler::cmd_start(const char* cmd)
+void ATHandler::cmd_start(const char *cmd)
 {
 
     if (_at_send_delay) {
@@ -998,7 +998,7 @@ void ATHandler::write_int(int32_t param)
     }
 }
 
-void ATHandler::write_string(const char* param, bool useQuotations)
+void ATHandler::write_string(const char *param, bool useQuotations)
 {
     // do common checks before sending subparameter
     if (check_cmd_send() == false) {
@@ -1042,18 +1042,18 @@ size_t ATHandler::write(const void *data, size_t len)
     fhs.fh = _fileHandle;
     fhs.events = POLLOUT;
     size_t write_len = 0;
-    for (; write_len < len; ) {
+    for (; write_len < len;) {
         int count = poll(&fhs, 1, poll_timeout());
         if (count <= 0 || !(fhs.revents & POLLOUT)) {
             set_error(NSAPI_ERROR_DEVICE_ERROR);
             return 0;
         }
-        ssize_t ret = _fileHandle->write((uint8_t*)data + write_len, len - write_len);
+        ssize_t ret = _fileHandle->write((uint8_t *)data + write_len, len - write_len);
         if (ret < 0) {
             set_error(NSAPI_ERROR_DEVICE_ERROR);
             return 0;
         }
-        debug_print((char*)data + write_len, ret);
+        debug_print((char *)data + write_len, ret);
         write_len += (size_t)ret;
     }