Changes data types to standard types.
platform/system/bt/tools/scripts/change_types.sh was used to convert:
UINT8->uint8_t
UINT32->uint32_t
UINT16->uint16_t
INT8->int8_t
INT32->int32_t
INT16->int16_t
Test: Compiles
Change-Id: I7fce2cbff75a2087db46cda7527437a46a627c46
Signed-off-by: Ruchi Kandoi <kandoiruchi@google.com>
diff --git a/src/gki/ulinux/gki_ulinux.c b/src/gki/ulinux/gki_ulinux.c
index e7aaa84..2b9e02f 100644
--- a/src/gki/ulinux/gki_ulinux.c
+++ b/src/gki/ulinux/gki_ulinux.c
@@ -79,9 +79,9 @@
typedef struct
{
- UINT8 task_id; /* GKI task id */
+ uint8_t task_id; /* GKI task id */
TASKPTR task_entry; /* Task entry function*/
- UINT32 params; /* Extra params to pass to task entry function */
+ uint32_t params; /* Extra params to pass to task entry function */
pthread_cond_t* pCond; /* for android*/
pthread_mutex_t* pMutex; /* for android*/
} gki_pthread_info_t;
@@ -96,7 +96,7 @@
** Returns void
**
*******************************************************************************/
-void gki_task_entry(UINT32 params)
+void gki_task_entry(uint32_t params)
{
pthread_t thread_id = pthread_self();
gki_pthread_info_t *p_pthread_info = (gki_pthread_info_t *)params;
@@ -150,7 +150,7 @@
gki_buffer_init();
gki_timers_init();
- gki_cb.com.OSTicks = (UINT32) times(0);
+ gki_cb.com.OSTicks = (uint32_t) times(0);
pthread_mutexattr_init(&attr);
@@ -183,7 +183,7 @@
** Returns Tick count of native OS.
**
*******************************************************************************/
-UINT32 GKI_get_os_tick_count(void)
+uint32_t GKI_get_os_tick_count(void)
{
/* TODO - add any OS specific code here
@@ -210,10 +210,10 @@
** of the function prototype.
**
*******************************************************************************/
-UINT8 GKI_create_task (TASKPTR task_entry, UINT8 task_id, INT8 *taskname, UINT16 *stack, UINT16 stacksize, void* pCondVar, void* pMutex)
+uint8_t GKI_create_task (TASKPTR task_entry, uint8_t task_id, int8_t *taskname, uint16_t *stack, uint16_t stacksize, void* pCondVar, void* pMutex)
{
- UINT16 i;
- UINT8 *p;
+ uint16_t i;
+ uint8_t *p;
struct sched_param param;
int policy, ret = 0;
pthread_condattr_t attr;
@@ -317,7 +317,7 @@
void GKI_shutdown(void)
{
- UINT8 task_id;
+ uint8_t task_id;
volatile int *p_run_cond = &gki_cb.os.no_timer_suspend;
int oldCOnd = 0;
#if ( FALSE == GKI_PTHREAD_JOINABLE )
@@ -396,7 +396,7 @@
** Returns void
**
*********************************************************************************/
-void gki_system_tick_start_stop_cback(BOOLEAN start)
+void gki_system_tick_start_stop_cback(bool start)
{
tGKI_OS *p_os = &gki_cb.os;
volatile int *p_run_cond = &p_os->no_timer_suspend;
@@ -582,7 +582,7 @@
*******************************************************************************/
void GKI_stop (void)
{
- UINT8 task_id;
+ uint8_t task_id;
/* gki_queue_timer_cback(FALSE); */
/* TODO - add code here if needed*/
@@ -613,10 +613,10 @@
** Returns the event mask of received events or zero if timeout
**
*******************************************************************************/
-UINT16 GKI_wait (UINT16 flag, UINT32 timeout)
+uint16_t GKI_wait (uint16_t flag, uint32_t timeout)
{
- UINT16 evt;
- UINT8 rtask;
+ uint16_t evt;
+ uint8_t rtask;
struct timespec abstime = { 0, 0 };
int sec;
int nano_sec;
@@ -746,9 +746,9 @@
**
*******************************************************************************/
-void GKI_delay (UINT32 timeout)
+void GKI_delay (uint32_t timeout)
{
- UINT8 rtask = GKI_get_taskid();
+ uint8_t rtask = GKI_get_taskid();
struct timespec delay;
int err;
@@ -792,7 +792,7 @@
** Returns GKI_SUCCESS if all OK, else GKI_FAILURE
**
*******************************************************************************/
-UINT8 GKI_send_event (UINT8 task_id, UINT16 event)
+uint8_t GKI_send_event (uint8_t task_id, uint16_t event)
{
GKI_TRACE_2("GKI_send_event %d %x", task_id, event);
@@ -835,7 +835,7 @@
** body of the function.
**
*******************************************************************************/
-UINT8 GKI_isend_event (UINT8 task_id, UINT16 event)
+uint8_t GKI_isend_event (uint8_t task_id, uint16_t event)
{
GKI_TRACE_2("GKI_isend_event %d %x", task_id, event);
@@ -858,7 +858,7 @@
** OS-specific method to determine the current task.
**
*******************************************************************************/
-UINT8 GKI_get_taskid (void)
+uint8_t GKI_get_taskid (void)
{
int i;
@@ -892,7 +892,7 @@
** NOTE this function needs no customization
**
*******************************************************************************/
-INT8 *GKI_map_taskname (UINT8 task_id)
+int8_t *GKI_map_taskname (uint8_t task_id)
{
GKI_TRACE_1("GKI_map_taskname %d", task_id);
@@ -907,7 +907,7 @@
}
else
{
- return (INT8*) "BAD";
+ return (int8_t*) "BAD";
}
}
@@ -968,9 +968,9 @@
**
*******************************************************************************/
-void GKI_exception (UINT16 code, char *msg)
+void GKI_exception (uint16_t code, char *msg)
{
- UINT8 task_id;
+ uint8_t task_id;
int i = 0;
GKI_TRACE_ERROR_0( "GKI_exception(): Task State Table");
@@ -1026,13 +1026,13 @@
** NOTE This function is only called by OBEX.
**
*******************************************************************************/
-INT8 *GKI_get_time_stamp (INT8 *tbuf)
+int8_t *GKI_get_time_stamp (int8_t *tbuf)
{
- UINT32 ms_time;
- UINT32 s_time;
- UINT32 m_time;
- UINT32 h_time;
- INT8 *p_out = tbuf;
+ uint32_t ms_time;
+ uint32_t s_time;
+ uint32_t m_time;
+ uint32_t h_time;
+ int8_t *p_out = tbuf;
gki_cb.com.OSTicks = times(0);
ms_time = GKI_TICKS_TO_MS(gki_cb.com.OSTicks);
@@ -1044,17 +1044,17 @@
s_time -= m_time*60;
m_time -= h_time*60;
- *p_out++ = (INT8)((h_time / 10) + '0');
- *p_out++ = (INT8)((h_time % 10) + '0');
+ *p_out++ = (int8_t)((h_time / 10) + '0');
+ *p_out++ = (int8_t)((h_time % 10) + '0');
*p_out++ = ':';
- *p_out++ = (INT8)((m_time / 10) + '0');
- *p_out++ = (INT8)((m_time % 10) + '0');
+ *p_out++ = (int8_t)((m_time / 10) + '0');
+ *p_out++ = (int8_t)((m_time % 10) + '0');
*p_out++ = ':';
- *p_out++ = (INT8)((s_time / 10) + '0');
- *p_out++ = (INT8)((s_time % 10) + '0');
+ *p_out++ = (int8_t)((s_time / 10) + '0');
+ *p_out++ = (int8_t)((s_time % 10) + '0');
*p_out++ = ':';
- *p_out++ = (INT8)((ms_time / 10) + '0');
- *p_out++ = (INT8)((ms_time % 10) + '0');
+ *p_out++ = (int8_t)((ms_time / 10) + '0');
+ *p_out++ = (int8_t)((ms_time % 10) + '0');
*p_out++ = ':';
*p_out = 0;
@@ -1099,7 +1099,7 @@
** dynamic memory allocation is used.
**
*******************************************************************************/
-void *GKI_os_malloc (UINT32 size)
+void *GKI_os_malloc (uint32_t size)
{
return (malloc(size));
}
@@ -1142,7 +1142,7 @@
** put specific code here.
**
*******************************************************************************/
-UINT8 GKI_suspend_task (UINT8 task_id)
+uint8_t GKI_suspend_task (uint8_t task_id)
{
GKI_TRACE_1("GKI_suspend_task %d - NOT implemented", task_id);
@@ -1168,7 +1168,7 @@
** put specific code here.
**
*******************************************************************************/
-UINT8 GKI_resume_task (UINT8 task_id)
+uint8_t GKI_resume_task (uint8_t task_id)
{
GKI_TRACE_1("GKI_resume_task %d - NOT implemented", task_id);
@@ -1194,7 +1194,7 @@
** put specific code here to kill a task.
**
*******************************************************************************/
-void GKI_exit_task (UINT8 task_id)
+void GKI_exit_task (uint8_t task_id)
{
GKI_disable();
gki_cb.com.OSRdyTbl[task_id] = TASK_DEAD;
@@ -1262,11 +1262,11 @@
** Description shift memory down (to make space to insert a record)
**
*******************************************************************************/
-void GKI_shiftdown (UINT8 *p_mem, UINT32 len, UINT32 shift_amount)
+void GKI_shiftdown (uint8_t *p_mem, uint32_t len, uint32_t shift_amount)
{
- register UINT8 *ps = p_mem + len - 1;
- register UINT8 *pd = ps + shift_amount;
- register UINT32 xx;
+ register uint8_t *ps = p_mem + len - 1;
+ register uint8_t *pd = ps + shift_amount;
+ register uint32_t xx;
for (xx = 0; xx < len; xx++)
*pd-- = *ps--;
@@ -1279,11 +1279,11 @@
** Description shift memory up (to delete a record)
**
*******************************************************************************/
-void GKI_shiftup (UINT8 *p_dest, UINT8 *p_src, UINT32 len)
+void GKI_shiftup (uint8_t *p_dest, uint8_t *p_src, uint32_t len)
{
- register UINT8 *ps = p_src;
- register UINT8 *pd = p_dest;
- register UINT32 xx;
+ register uint8_t *ps = p_src;
+ register uint8_t *pd = p_dest;
+ register uint32_t xx;
for (xx = 0; xx < len; xx++)
*pd++ = *ps++;