add support for AliOS Things (#34)

* Add support of AliOS-Things

* update the README.md format

* update the README.md #1

* update the README.md #2

core/shared-lib/platform/alios/bh_assert.c

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_platform.h"
+#include "bh_assert.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef BH_TEST
+#include <setjmp.h>
+#endif
+
+#ifdef BH_TEST
+/* for exception throwing */
+jmp_buf bh_test_jb;
+#endif
+
+void bh_assert_internal(int v, const char *file_name, int line_number, const char *expr_string)
+{
+  if(v) return;
+
+  if(!file_name) file_name = "NULL FILENAME";
+  if(!expr_string) expr_string = "NULL EXPR_STRING";
+
+  printf("\nASSERTION FAILED: %s, at FILE=%s, LINE=%d\n", expr_string, file_name, line_number);
+
+#ifdef BH_TEST
+  longjmp(bh_test_jb, 1);
+#endif
+
+  aos_reboot();
+}
+
+void bh_debug_internal(const char *file_name, int line_number, const char *fmt, ...)
+{
+#ifndef JEFF_TEST_VERIFIER
+  va_list args;
+
+  va_start(args, fmt);
+  bh_assert(file_name);
+
+  printf("\nDebug info FILE=%s, LINE=%d: ", file_name, line_number);
+  vprintf(fmt, args);
+
+  va_end(args);
+  printf("\n");
+#endif
+}
+

core/shared-lib/platform/alios/bh_definition.c

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_definition.h"
+#include "bh_platform.h"
+
+int bh_return(int ret)
+{
+  return ret;
+}
+
+#define RSIZE_MAX 0x7FFFFFFF
+
+int b_memcpy_s(void * s1, unsigned int s1max,
+               const void * s2, unsigned int n)
+{
+  char *dest = (char*)s1;
+  char *src = (char*)s2;
+  if (n == 0) {
+    return 0;
+  }
+
+  if (s1 == NULL || s1max > RSIZE_MAX) {
+    return -1;
+  }
+  if (s2 == NULL || n > s1max) {
+    memset(dest, 0, s1max);
+    return -1;
+  }
+  memcpy(dest, src, n);
+  return 0;
+}
+
+int b_strcat_s(char * s1, size_t s1max, const char * s2)
+{
+  if (NULL == s1 || NULL == s2
+      || s1max < (strlen(s1) + strlen(s2) + 1)
+      || s1max > RSIZE_MAX) {
+    return -1;
+  }
+
+  strcat(s1, s2);
+  return 0;
+}
+
+int b_strcpy_s(char * s1, size_t s1max, const char * s2)
+{
+  if (NULL == s1 || NULL == s2
+      || s1max < (strlen(s2) + 1)
+      || s1max > RSIZE_MAX) {
+    return -1;
+  }
+
+  strcpy(s1, s2);
+  return 0;
+}
+

core/shared-lib/platform/alios/bh_platform.c

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_platform.h"
+#include <stdlib.h>
+#include <string.h>
+
+char *bh_strdup(const char *s)
+{
+    char *s1 = NULL;
+    if (s && (s1 = bh_malloc(strlen(s) + 1)))
+        memcpy(s1, s, strlen(s) + 1);
+    return s1;
+}

core/shared-lib/platform/alios/bh_platform.h

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _BH_PLATFORM_H
+#define _BH_PLATFORM_H
+
+#include "bh_config.h"
+#include "bh_types.h"
+#include "bh_memory.h"
+#include <aos/kernel.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+/* Platform name */
+#define BH_PLATFORM "AliOS-Things"
+
+#define BH_APPLET_PRESERVED_STACK_SIZE (2 * BH_KB)
+
+/* Default thread priority */
+#define BH_THREAD_DEFAULT_PRIORITY 30
+
+#define BH_ROUTINE_MODIFIER
+
+/* Invalid thread tid */
+#define INVALID_THREAD_ID NULL
+
+#define INVALID_SEM_ID NULL
+
+#define BH_WAIT_FOREVER AOS_WAIT_FOREVER
+
+typedef uint64_t uint64;
+typedef int64_t int64;
+
+#define wa_malloc bh_malloc
+#define wa_free bh_free
+#define wa_strdup bh_strdup
+
+typedef aos_task_t korp_thread;
+typedef korp_thread *korp_tid;
+typedef aos_task_t *aos_tid_t;
+typedef aos_mutex_t korp_mutex;
+typedef aos_sem_t korp_sem;
+
+struct bh_thread_wait_node;
+typedef struct bh_thread_wait_node *bh_thread_wait_list;
+typedef struct korp_cond {
+  aos_mutex_t wait_list_lock;
+  bh_thread_wait_list thread_wait_list;
+} korp_cond;
+
+typedef void* (*thread_start_routine_t)(void*);
+
+/* Unit test framework is based on C++, where the declaration of
+   snprintf is different.  */
+#ifndef __cplusplus
+int snprintf(char *buffer, size_t count, const char *format, ...);
+#endif
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+extern void bh_assert_internal(int v, const char *file_name, int line_number, const char *expr_string);
+#define bh_assert(expr) bh_assert_internal((int)(expr), __FILE__, __LINE__, # expr)
+
+extern int b_memcpy_s(void * s1, unsigned int s1max, const void * s2, unsigned int n);
+extern int b_strcat_s(char * s1, size_t s1max, const char * s2);
+extern int b_strcpy_s(char * s1, size_t s1max, const char * s2);
+
+#endif /* end of _BH_PLATFORM_H */
+

core/shared-lib/platform/alios/bh_platform_log.c

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_platform.h"
+#include <stdio.h>
+
+
+void bh_log_emit(const char *fmt, va_list ap)
+{
+  vprintf(fmt, ap);
+}
+
+int bh_fprintf(FILE *stream, const char *fmt, ...)
+{
+  (void)stream;
+  va_list ap;
+  int ret;
+
+  va_start(ap, fmt);
+  ret = vprintf(fmt, ap);
+  va_end(ap);
+
+  return ret;
+}
+
+int bh_fflush(void *stream)
+{
+  (void)stream;
+  return 0;
+}
+

core/shared-lib/platform/alios/bh_thread.c

@@ -0,0 +1,447 @@
+/*
+ * INTEL CONFIDENTIAL
+ *
+ * Copyright 2017-2018 Intel Corporation
+ *
+ * This software and the related documents are Intel copyrighted materials,
+ * and your use of them is governed by the express license under which they
+ * were provided to you (License). Unless the License provides otherwise, you
+ * may not use, modify, copy, publish, distribute, disclose or transmit this
+ * software or the related documents without Intel's prior written permission.
+ *
+ * This software and the related documents are provided as is, with no express
+ * or implied warranties, other than those that are expressly stated in the
+ * License.
+*/
+
+#include "bh_thread.h"
+#include "bh_assert.h"
+#include "bh_log.h"
+#include "bh_memory.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+
+struct bh_thread_data;
+typedef struct bh_thread_wait_node {
+  aos_sem_t sem;
+  bh_thread_wait_list next;
+} bh_thread_wait_node;
+
+typedef struct bh_thread_data {
+  /* Thread body */
+  aos_task_t thread;
+  /* Thread start routine */
+  thread_start_routine_t start_routine;
+  /* Thread start routine argument */
+  void *arg;
+  /* Thread local root */
+  void *tlr;
+  /* Wait node of current thread */
+  bh_thread_wait_node wait_node;
+  /* Lock for waiting list */
+  aos_mutex_t wait_list_lock;
+  /* Waiting list of other threads who are joining this thread */
+  bh_thread_wait_list thread_wait_list;
+} bh_thread_data;
+
+static bool is_thread_sys_inited = false;
+
+/* Thread data of supervisor thread */
+static bh_thread_data supervisor_thread_data;
+
+/* Thread data key */
+static aos_task_key_t thread_data_key;
+
+/* Thread name index */
+static int thread_name_index;
+
+int
+_vm_thread_sys_init()
+{
+  if (is_thread_sys_inited)
+    return BHT_OK;
+
+  if (aos_task_key_create(&thread_data_key) != 0)
+    return BHT_ERROR;
+
+  /* Initialize supervisor thread data */
+  memset(&supervisor_thread_data, 0, sizeof(supervisor_thread_data));
+
+  if (aos_sem_new(&supervisor_thread_data.wait_node.sem, 1) != 0) {
+    aos_task_key_delete(thread_data_key);
+    return BHT_ERROR;
+  }
+
+  if (aos_task_setspecific(thread_data_key, &supervisor_thread_data)) {
+    aos_sem_free(&supervisor_thread_data.wait_node.sem);
+    aos_task_key_delete(thread_data_key);
+    return BHT_ERROR;
+  }
+
+  is_thread_sys_inited = true;
+  return BHT_OK;
+}
+
+void
+vm_thread_sys_destroy()
+{
+  if (is_thread_sys_inited) {
+    aos_task_key_delete(thread_data_key);
+    aos_sem_free(&supervisor_thread_data.wait_node.sem);
+    is_thread_sys_inited = false;
+  }
+}
+
+static bh_thread_data *
+thread_data_current()
+{
+  return aos_task_getspecific(thread_data_key);
+}
+
+static void
+vm_thread_cleanup(void)
+{
+  bh_thread_data *thread_data = thread_data_current();
+  bh_thread_wait_list thread_wait_list;
+  aos_mutex_t *wait_list_lock;
+  aos_sem_t *wait_node_sem;
+
+  bh_assert(thread_data != NULL);
+  wait_list_lock = &thread_data->wait_list_lock;
+  thread_wait_list = thread_data->thread_wait_list;
+  wait_node_sem = &thread_data->wait_node.sem;
+
+  /* Free thread data firstly */
+  bh_free(thread_data);
+
+  aos_mutex_lock(wait_list_lock, AOS_WAIT_FOREVER);
+  if (thread_wait_list) {
+    /* Signal each joining thread */
+    bh_thread_wait_list head = thread_wait_list;
+    while (head) {
+      bh_thread_wait_list next = head->next;
+      aos_sem_signal(&head->sem);
+      head = next;
+    }
+  }
+  aos_mutex_unlock(wait_list_lock);
+
+  /* Free sem and lock */
+  aos_sem_free(wait_node_sem);
+  aos_mutex_free(wait_list_lock);
+}
+
+static void
+vm_thread_wrapper(void *arg)
+{
+  bh_thread_data *thread_data = arg;
+
+  /* Set thread custom data */
+  if (!aos_task_setspecific(thread_data_key, thread_data))
+    thread_data->start_routine(thread_data->arg);
+
+  vm_thread_cleanup();
+}
+
+int
+_vm_thread_create(korp_tid *p_tid, thread_start_routine_t start,
+                  void *arg, unsigned int stack_size)
+{
+  return _vm_thread_create_with_prio(p_tid, start, arg, stack_size,
+                                     BH_THREAD_DEFAULT_PRIORITY);
+}
+
+int
+_vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
+                            void *arg, unsigned int stack_size, int prio)
+{
+  bh_thread_data *thread_data;
+  char thread_name[32];
+
+  if (!p_tid || !stack_size)
+    return BHT_ERROR;
+
+  /* Create and initialize thread data */
+  if (!(thread_data = bh_malloc(sizeof(bh_thread_data))))
+    return BHT_ERROR;
+
+  memset(thread_data, 0, sizeof(bh_thread_data));
+
+  thread_data->start_routine = start;
+  thread_data->arg = arg;
+
+  if (aos_sem_new(&thread_data->wait_node.sem, 1) != 0)
+    goto fail1;
+
+  if (aos_mutex_new(&thread_data->wait_list_lock))
+    goto fail2;
+
+  snprintf(thread_name, sizeof(thread_name), "%s%d",
+           "wasm-thread-", ++thread_name_index);
+
+  /* Create the thread */
+  if (aos_task_new_ext((aos_task_t*)thread_data, thread_name,
+                        vm_thread_wrapper, thread_data,
+                        stack_size, prio))
+    goto fail3;
+
+  aos_msleep(10);
+  *p_tid = (korp_tid)thread_data;
+  return BHT_OK;
+
+fail3:
+  aos_mutex_free(&thread_data->wait_list_lock);
+fail2:
+  aos_sem_free(&thread_data->wait_node.sem);
+fail1:
+  bh_free(thread_data);
+  return BHT_ERROR;
+}
+
+korp_tid
+_vm_self_thread()
+{
+  return (korp_tid)aos_task_getspecific(thread_data_key);
+}
+
+void
+vm_thread_exit(void * code)
+{
+  vm_thread_cleanup();
+  aos_task_exit((int)(intptr_t)code);
+}
+
+int
+_vm_thread_cancel (korp_tid thread)
+{
+  /* TODO */
+  return 0;
+}
+
+int
+_vm_thread_join (korp_tid thread, void **value_ptr, int mills)
+{
+  (void)value_ptr;
+  bh_thread_data *thread_data, *curr_thread_data;
+
+  /* Get thread data of current thread */
+  curr_thread_data = thread_data_current();
+  curr_thread_data->wait_node.next = NULL;
+
+  /* Get thread data */
+  thread_data = (bh_thread_data*)thread;
+
+  aos_mutex_lock(&thread_data->wait_list_lock, AOS_WAIT_FOREVER);
+  if (!thread_data->thread_wait_list)
+    thread_data->thread_wait_list = &curr_thread_data->wait_node;
+  else {
+    /* Add to end of waiting list */
+    bh_thread_wait_node *p = thread_data->thread_wait_list;
+    while (p->next)
+      p = p->next;
+    p->next = &curr_thread_data->wait_node;
+  }
+  aos_mutex_unlock(&thread_data->wait_list_lock);
+
+  /* Wait the sem */
+  aos_sem_wait(&curr_thread_data->wait_node.sem, mills);
+
+  return BHT_OK;
+}
+
+int
+_vm_thread_detach (korp_tid thread)
+{
+  (void)thread;
+  return BHT_OK;
+}
+
+void *
+_vm_tls_get(unsigned idx)
+{
+  (void)idx;
+  bh_thread_data *thread_data;
+
+  bh_assert (idx == 0);
+  thread_data = thread_data_current();
+
+  return thread_data ? thread_data->tlr : NULL;
+}
+
+int
+_vm_tls_put(unsigned idx, void * tls)
+{
+  bh_thread_data *thread_data;
+
+  (void)idx;
+  bh_assert (idx == 0);
+  thread_data = thread_data_current();
+  bh_assert (thread_data != NULL);
+
+  thread_data->tlr = tls;
+  return BHT_OK;
+}
+
+int
+_vm_mutex_init(korp_mutex *mutex)
+{
+  return aos_mutex_new(mutex) == 0 ? BHT_OK : BHT_ERROR;
+}
+
+int
+_vm_recursive_mutex_init(korp_mutex *mutex)
+{
+  return aos_mutex_new(mutex) == 0 ? BHT_OK : BHT_ERROR;
+}
+
+int
+_vm_mutex_destroy(korp_mutex *mutex)
+{
+  aos_mutex_free(mutex);
+  return BHT_OK;
+}
+
+void
+vm_mutex_lock(korp_mutex *mutex)
+{
+  aos_mutex_lock(mutex, AOS_WAIT_FOREVER);
+}
+
+int
+vm_mutex_trylock(korp_mutex *mutex)
+{
+  return aos_mutex_lock(mutex, AOS_NO_WAIT);
+}
+
+void vm_mutex_unlock(korp_mutex *mutex)
+{
+  aos_mutex_unlock(mutex);
+}
+
+int _vm_sem_init(korp_sem* sem, unsigned int c)
+{
+  return aos_sem_new(sem, c) == 0 ? BHT_OK : BHT_ERROR;
+}
+
+int _vm_sem_destroy(korp_sem *sem)
+{
+  aos_sem_free(sem);
+  return BHT_OK;
+}
+
+int _vm_sem_wait(korp_sem *sem)
+{
+  return aos_sem_wait(sem, AOS_WAIT_FOREVER);
+}
+
+int _vm_sem_reltimedwait(korp_sem *sem, int mills)
+{
+  return aos_sem_wait(sem, mills);
+}
+
+int _vm_sem_post(korp_sem *sem)
+{
+  aos_sem_signal(sem);
+  return BHT_OK;
+}
+
+int
+_vm_cond_init(korp_cond *cond)
+{
+  if (aos_mutex_new(&cond->wait_list_lock) != 0)
+    return BHT_ERROR;
+
+  cond->thread_wait_list = NULL;
+  return BHT_OK;
+}
+
+int
+_vm_cond_destroy(korp_cond *cond)
+{
+  aos_mutex_free(&cond->wait_list_lock);
+  return BHT_OK;
+}
+
+static int
+vm_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
+                      bool timed, int mills)
+{
+  bh_thread_wait_node *node = &thread_data_current()->wait_node;
+
+  node->next = NULL;
+
+  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+  if (!cond->thread_wait_list)
+    cond->thread_wait_list = node;
+  else {
+    /* Add to end of wait list */
+    bh_thread_wait_node *p = cond->thread_wait_list;
+    while (p->next)
+      p = p->next;
+    p->next = node;
+  }
+  aos_mutex_unlock(&cond->wait_list_lock);
+
+  /* Unlock mutex, wait sem and lock mutex again */
+  aos_mutex_unlock(mutex);
+  aos_sem_wait(&node->sem, timed ? mills : AOS_WAIT_FOREVER);
+  aos_mutex_lock(mutex, AOS_WAIT_FOREVER);
+
+  /* Remove wait node from wait list */
+  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+  if (cond->thread_wait_list == node)
+    cond->thread_wait_list = node->next;
+  else {
+    /* Remove from the wait list */
+    bh_thread_wait_node *p = cond->thread_wait_list;
+    while (p->next != node)
+      p = p->next;
+    p->next = node->next;
+  }
+  aos_mutex_unlock(&cond->wait_list_lock);
+
+  return BHT_OK;
+}
+
+int
+_vm_cond_wait(korp_cond *cond, korp_mutex *mutex)
+{
+  return vm_cond_wait_internal(cond, mutex, false, 0);
+}
+
+int
+_vm_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int mills)
+{
+  return vm_cond_wait_internal(cond, mutex, true, mills);
+}
+
+int
+_vm_cond_signal(korp_cond *cond)
+{
+  /* Signal the head wait node of wait list */
+  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+  if (cond->thread_wait_list)
+    aos_sem_signal(&cond->thread_wait_list->sem);
+  aos_mutex_unlock(&cond->wait_list_lock);
+
+  return BHT_OK;
+}
+
+int
+_vm_cond_broadcast (korp_cond *cond)
+{
+  /* Signal each wait node of wait list */
+  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+  if (cond->thread_wait_list) {
+    bh_thread_wait_node *p = cond->thread_wait_list;
+    while (p) {
+      aos_sem_signal(&p->sem);
+      p = p->next;
+    }
+  }
+  aos_mutex_unlock(&cond->wait_list_lock);
+
+  return BHT_OK;
+}
+

core/shared-lib/platform/alios/bh_time.c

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_time.h"
+
+/*
+ * This function returns milliseconds per tick.
+ * @return milliseconds per tick.
+ */
+uint64 _bh_time_get_tick_millisecond()
+{
+  return aos_get_hz() / 1000();
+}
+
+/*
+ * This function returns milliseconds after boot.
+ * @return milliseconds after boot.
+ */
+uint64 _bh_time_get_boot_millisecond()
+{
+  return (uint64)aos_now_ms();
+}
+
+uint64 _bh_time_get_millisecond_from_1970()
+{
+  return (uint64)aos_now_ms();
+}
+
+size_t
+_bh_time_strftime (char *str, size_t max, const char *format, int64 time)
+{
+  str = aos_now_time_str(str, max);
+  return str ? strlen(str) + 1 : 0;
+}
+

core/shared-lib/platform/alios/shared_platform.cmake

@@ -0,0 +1,24 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+include_directories(${PLATFORM_SHARED_DIR})
+include_directories(${PLATFORM_SHARED_DIR}/../include)
+
+
+file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
+
+set (PLATFORM_SHARED_SOURCE ${source_all})
+