You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by ma...@apache.org on 2016/10/04 19:04:00 UTC
[08/13] incubator-mynewt-core git commit: move libs/iotivity ->
net/oic.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_etimer.h
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_etimer.h b/libs/iotivity/src/util/oc_etimer.h
deleted file mode 100644
index 703b557..0000000
--- a/libs/iotivity/src/util/oc_etimer.h
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * Copyright (c) 2016 Intel Corporation
- *
- * Copyright (c) 2004, Swedish Institute of Computer Science.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- * Author: Adam Dunkels <ad...@sics.se>
- *
- */
-
-/**
- * \defgroup etimer Event timers
- *
- * Event timers provides a way to generate timed events. An event
- * timer will post an event to the process that set the timer when the
- * event timer expires.
- *
- * An event timer is declared as a \c struct \c etimer and all access
- * to the event timer is made by a pointer to the declared event
- * timer.
- *
- * \sa \ref timer "Simple timer library"
- * \sa \ref clock "Clock library" (used by the timer library)
- *
- * @{
- */
-
-#ifndef OC_ETIMER_H
-#define OC_ETIMER_H
-
-#include "oc_process.h"
-#include "oc_timer.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * A timer.
- *
- * This structure is used for declaring a timer. The timer must be set
- * with oc_etimer_set() before it can be used.
- *
- * \hideinitializer
- */
-struct oc_etimer
-{
- struct oc_timer timer;
- struct oc_etimer *next;
- struct oc_process *p;
-};
-
-/**
- * \name Functions called from application programs
- * @{
- */
-
-/**
- * \brief Set an event timer.
- * \param et A pointer to the event timer
- * \param interval The interval before the timer expires.
- *
- * This function is used to set an event timer for a time
- * sometime in the future. When the event timer expires,
- * the event PROCESS_EVENT_TIMER will be posted to the
- * process that called the oc_etimer_set() function.
- *
- */
-void oc_etimer_set(struct oc_etimer *et, oc_clock_time_t interval);
-
-/**
- * \brief Reset an event timer with the same interval as was
- * previously set.
- * \param et A pointer to the event timer.
- *
- * This function resets the event timer with the same
- * interval that was given to the event timer with the
- * oc_etimer_set() function. The start point of the interval
- * is the exact time that the event timer last
- * expired. Therefore, this function will cause the timer
- * to be stable over time, unlike the oc_etimer_restart()
- * function.
- *
- * \sa oc_etimer_restart()
- */
-void oc_etimer_reset(struct oc_etimer *et);
-
-/**
- * \brief Reset an event timer with a new interval.
- * \param et A pointer to the event timer.
- * \param interval The interval before the timer expires.
- *
- * This function very similar to oc_etimer_reset. Opposed to
- * oc_etimer_reset it is possible to change the timout.
- * This allows accurate, non-periodic timers without drift.
- *
- * \sa oc_etimer_reset()
- */
-void oc_etimer_reset_with_new_interval(struct oc_etimer *et,
- oc_clock_time_t interval);
-
-/**
- * \brief Restart an event timer from the current point in time
- * \param et A pointer to the event timer.
- *
- * This function restarts the event timer with the same
- * interval that was given to the oc_etimer_set()
- * function. The event timer will start at the current
- * time.
- *
- * \note A periodic timer will drift if this function is
- * used to reset it. For periodic timers, use the
- * oc_etimer_reset() function instead.
- *
- * \sa oc_etimer_reset()
- */
-void oc_etimer_restart(struct oc_etimer *et);
-
-/**
- * \brief Adjust the expiration time for an event timer
- * \param et A pointer to the event timer.
- * \param td The time difference to adjust the expiration time with.
- *
- * This function is used to adjust the time the event
- * timer will expire. It can be used to synchronize
- * periodic timers without the need to restart the timer
- * or change the timer interval.
- *
- * \note This function should only be used for small
- * adjustments. For large adjustments use oc_etimer_set()
- * instead.
- *
- * \note A periodic timer will drift unless the
- * oc_etimer_reset() function is used.
- *
- * \sa oc_etimer_set()
- * \sa oc_etimer_reset()
- */
-void oc_etimer_adjust(struct oc_etimer *et, int td);
-
-/**
- * \brief Get the expiration time for the event timer.
- * \param et A pointer to the event timer
- * \return The expiration time for the event timer.
- *
- * This function returns the expiration time for an event timer.
- */
-oc_clock_time_t oc_etimer_expiration_time(struct oc_etimer *et);
-
-/**
- * \brief Get the start time for the event timer.
- * \param et A pointer to the event timer
- * \return The start time for the event timer.
- *
- * This function returns the start time (when the timer
- * was last set) for an event timer.
- */
-oc_clock_time_t oc_etimer_start_time(struct oc_etimer *et);
-
-/**
- * \brief Check if an event timer has expired.
- * \param et A pointer to the event timer
- * \return Non-zero if the timer has expired, zero otherwise.
- *
- * This function tests if an event timer has expired and
- * returns true or false depending on its status.
- */
-int oc_etimer_expired(struct oc_etimer *et);
-
-/**
- * \brief Stop a pending event timer.
- * \param et A pointer to the pending event timer.
- *
- * This function stops an event timer that has previously
- * been set with oc_etimer_set() or oc_etimer_reset(). After
- * this function has been called, the event timer will not
- * emit any event when it expires.
- *
- */
-void oc_etimer_stop(struct oc_etimer *et);
-
-/** @} */
-
-/**
- * \name Functions called from timer interrupts, by the system
- * @{
- */
-
-/**
- * \brief Make the event timer aware that the clock has changed
- *
- * This function is used to inform the event timer module
- * that the system clock has been updated. Typically, this
- * function would be called from the timer interrupt
- * handler when the clock has ticked.
- */
-oc_clock_time_t oc_etimer_request_poll(void);
-
-/**
- * \brief Check if there are any non-expired event timers.
- * \return True if there are active event timers, false if there are
- * no active timers.
- *
- * This function checks if there are any active event
- * timers that have not expired.
- */
-int oc_etimer_pending(void);
-
-/**
- * \brief Get next event timer expiration time.
- * \return Next expiration time of all pending event timers.
- * If there are no pending event timers this function
- * returns 0.
- *
- * This functions returns next expiration time of all
- * pending event timers.
- */
-oc_clock_time_t oc_etimer_next_expiration_time(void);
-
-/** @} */
-
-OC_PROCESS_NAME(oc_etimer_process);
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* OC_ETIMER_H */
-/** @} */
-/** @} */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_list.c
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_list.c b/libs/iotivity/src/util/oc_list.c
deleted file mode 100644
index 429f411..0000000
--- a/libs/iotivity/src/util/oc_list.c
+++ /dev/null
@@ -1,317 +0,0 @@
-/*
- * Copyright (c) 2004, Swedish Institute of Computer Science.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- * Author: Adam Dunkels <ad...@sics.se>
- *
- */
-
-#include "oc_list.h"
-
-#define NULL 0
-
-struct list
-{
- struct list *next;
-};
-
-/*---------------------------------------------------------------------------*/
-/**
- * Initialize a list.
- *
- * This function initalizes a list. The list will be empty after this
- * function has been called.
- *
- * \param list The list to be initialized.
- */
-void
-oc_list_init(oc_list_t list)
-{
- *list = NULL;
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Get a pointer to the first element of a list.
- *
- * This function returns a pointer to the first element of the
- * list. The element will \b not be removed from the list.
- *
- * \param list The list.
- * \return A pointer to the first element on the list.
- *
- * \sa oc_list_tail()
- */
-void *
-oc_list_head(oc_list_t list)
-{
- return *list;
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Duplicate a list.
- *
- * This function duplicates a list by copying the list reference, but
- * not the elements.
- *
- * \note This function does \b not copy the elements of the list, but
- * merely duplicates the pointer to the first element of the list.
- *
- * \param dest The destination list.
- * \param src The source list.
- */
-void
-oc_list_copy(oc_list_t dest, oc_list_t src)
-{
- *dest = *src;
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Get the tail of a list.
- *
- * This function returns a pointer to the elements following the first
- * element of a list. No elements are removed by this function.
- *
- * \param list The list
- * \return A pointer to the element after the first element on the list.
- *
- * \sa oc_list_head()
- */
-void *
-oc_list_tail(oc_list_t list)
-{
- struct list *l;
-
- if (*list == NULL) {
- return NULL;
- }
-
- for (l = *list; l->next != NULL; l = l->next)
- ;
-
- return l;
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Add an item at the end of a list.
- *
- * This function adds an item to the end of the list.
- *
- * \param list The list.
- * \param item A pointer to the item to be added.
- *
- * \sa oc_list_push()
- *
- */
-void
-oc_list_add(oc_list_t list, void *item)
-{
- struct list *l;
-
- /* Make sure not to add the same element twice */
- oc_list_remove(list, item);
-
- ((struct list *)item)->next = NULL;
-
- l = oc_list_tail(list);
-
- if (l == NULL) {
- *list = item;
- } else {
- l->next = item;
- }
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Add an item to the start of the list.
- */
-void
-oc_list_push(oc_list_t list, void *item)
-{
- /* Make sure not to add the same element twice */
- oc_list_remove(list, item);
-
- ((struct list *)item)->next = *list;
- *list = item;
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Remove the last object on the list.
- *
- * This function removes the last object on the list and returns it.
- *
- * \param list The list
- * \return The removed object
- *
- */
-void *
-oc_list_chop(oc_list_t list)
-{
- struct list *l, *r;
-
- if (*list == NULL) {
- return NULL;
- }
- if (((struct list *)*list)->next == NULL) {
- l = *list;
- *list = NULL;
- return l;
- }
-
- for (l = *list; l->next->next != NULL; l = l->next)
- ;
-
- r = l->next;
- l->next = NULL;
-
- return r;
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Remove the first object on a list.
- *
- * This function removes the first object on the list and returns a
- * pointer to it.
- *
- * \param list The list.
- * \return Pointer to the removed element of list.
- */
-/*---------------------------------------------------------------------------*/
-void *
-oc_list_pop(oc_list_t list)
-{
- struct list *l;
- l = *list;
- if (*list != NULL) {
- *list = ((struct list *)*list)->next;
- }
-
- return l;
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Remove a specific element from a list.
- *
- * This function removes a specified element from the list.
- *
- * \param list The list.
- * \param item The item that is to be removed from the list.
- *
- */
-/*---------------------------------------------------------------------------*/
-void
-oc_list_remove(oc_list_t list, void *item)
-{
- struct list *l, *r;
-
- if (*list == NULL) {
- return;
- }
-
- r = NULL;
- for (l = *list; l != NULL; l = l->next) {
- if (l == item) {
- if (r == NULL) {
- /* First on list */
- *list = l->next;
- } else {
- /* Not first on list */
- r->next = l->next;
- }
- l->next = NULL;
- return;
- }
- r = l;
- }
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Get the length of a list.
- *
- * This function counts the number of elements on a specified list.
- *
- * \param list The list.
- * \return The length of the list.
- */
-/*---------------------------------------------------------------------------*/
-int
-oc_list_length(oc_list_t list)
-{
- struct list *l;
- int n = 0;
-
- for (l = *list; l != NULL; l = l->next) {
- ++n;
- }
-
- return n;
-}
-/*---------------------------------------------------------------------------*/
-/**
- * \brief Insert an item after a specified item on the list
- * \param list The list
- * \param previtem The item after which the new item should be inserted
- * \param newitem The new item that is to be inserted
- * \author Adam Dunkels
- *
- * This function inserts an item right after a specified
- * item on the list. This function is useful when using
- * the list module to ordered lists.
- *
- * If previtem is NULL, the new item is placed at the
- * start of the list.
- *
- */
-void
-oc_list_insert(oc_list_t list, void *previtem, void *newitem)
-{
- if (previtem == NULL) {
- oc_list_push(list, newitem);
- } else {
-
- ((struct list *)newitem)->next = ((struct list *)previtem)->next;
- ((struct list *)previtem)->next = newitem;
- }
-}
-/*---------------------------------------------------------------------------*/
-/**
- * \brief Get the next item following this item
- * \param item A list item
- * \returns A next item on the list
- *
- * This function takes a list item and returns the next
- * item on the list, or NULL if there are no more items on
- * the list. This function is used when iterating through
- * lists.
- */
-void *
-oc_list_item_next(void *item)
-{
- return item == NULL ? NULL : ((struct list *)item)->next;
-}
-/*---------------------------------------------------------------------------*/
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_list.h
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_list.h b/libs/iotivity/src/util/oc_list.h
deleted file mode 100644
index c0f5db8..0000000
--- a/libs/iotivity/src/util/oc_list.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright (c) 2004, Swedish Institute of Computer Science.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- * Author: Adam Dunkels <ad...@sics.se>
- *
- */
-
-/**
- * \defgroup list Linked list library
- *
- * The linked list library provides a set of functions for
- * manipulating linked lists.
- *
- * A linked list is made up of elements where the first element \b
- * must be a pointer. This pointer is used by the linked list library
- * to form lists of the elements.
- *
- * Lists are declared with the LIST() macro. The declaration specifies
- * the name of the list that later is used with all list functions.
- *
- * Lists can be manipulated by inserting or removing elements from
- * either sides of the list (list_push(), list_add(), list_pop(),
- * list_chop()). A specified element can also be removed from inside a
- * list with list_remove(). The head and tail of a list can be
- * extracted using list_head() and list_tail(), respectively.
- *
- */
-
-#ifndef OC_LIST_H
-#define OC_LIST_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define OC_LIST_CONCAT2(s1, s2) s1##s2
-#define OC_LIST_CONCAT(s1, s2) OC_LIST_CONCAT2(s1, s2)
-
-/**
- * Declare a linked list.
- *
- * This macro declares a linked list with the specified \c type. The
- * type \b must be a structure (\c struct) with its first element
- * being a pointer. This pointer is used by the linked list library to
- * form the linked lists.
- *
- * The list variable is declared as static to make it easy to use in a
- * single C module without unnecessarily exporting the name to other
- * modules.
- *
- * \param name The name of the list.
- */
-#define OC_LIST(name) \
- static void *OC_LIST_CONCAT(name, _list) = NULL; \
- static oc_list_t name = (oc_list_t)&OC_LIST_CONCAT(name, _list)
-
-/**
- * Declare a linked list inside a structure declaraction.
- *
- * This macro declares a linked list with the specified \c type. The
- * type \b must be a structure (\c struct) with its first element
- * being a pointer. This pointer is used by the linked list library to
- * form the linked lists.
- *
- * Internally, the list is defined as two items: the list itself and a
- * pointer to the list. The pointer has the name of the parameter to
- * the macro and the name of the list is a concatenation of the name
- * and the suffix "_list". The pointer must point to the list for the
- * list to work. Thus the list must be initialized before using.
- *
- * The list is initialized with the LIST_STRUCT_INIT() macro.
- *
- * \param name The name of the list.
- */
-#define OC_LIST_STRUCT(name) \
- void *OC_LIST_CONCAT(name, _list); \
- oc_list_t name
-
-/**
- * Initialize a linked list that is part of a structure.
- *
- * This macro sets up the internal pointers in a list that has been
- * defined as part of a struct. This macro must be called before using
- * the list.
- *
- * \param struct_ptr A pointer to the struct
- * \param name The name of the list.
- */
-#define OC_LIST_STRUCT_INIT(struct_ptr, name) \
- do { \
- (struct_ptr)->name = &((struct_ptr)->OC_LIST_CONCAT(name, _list)); \
- (struct_ptr)->OC_LIST_CONCAT(name, _list) = NULL; \
- oc_list_init((struct_ptr)->name); \
- } while (0)
-
-/**
- * The linked list type.
- *
- */
-typedef void **oc_list_t;
-
-void oc_list_init(oc_list_t list);
-void *oc_list_head(oc_list_t list);
-void *oc_list_tail(oc_list_t list);
-void *oc_list_pop(oc_list_t list);
-void oc_list_push(oc_list_t list, void *item);
-
-void *oc_list_chop(oc_list_t list);
-
-void oc_list_add(oc_list_t list, void *item);
-void oc_list_remove(oc_list_t list, void *item);
-
-int oc_list_length(oc_list_t list);
-
-void oc_list_copy(oc_list_t dest, oc_list_t src);
-
-void oc_list_insert(oc_list_t list, void *previtem, void *newitem);
-
-void *oc_list_item_next(void *item);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* OC_LIST_H */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_memb.c
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_memb.c b/libs/iotivity/src/util/oc_memb.c
deleted file mode 100644
index 31909a9..0000000
--- a/libs/iotivity/src/util/oc_memb.c
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright (c) 2004, Swedish Institute of Computer Science.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- * Author: Adam Dunkels <ad...@sics.se>
- *
- */
-
-#include "oc_memb.h"
-#include <string.h>
-
-/*---------------------------------------------------------------------------*/
-void
-oc_memb_init(struct oc_memb *m)
-{
- memset(m->count, 0, m->num);
- memset(m->mem, 0, (unsigned)m->size * (unsigned)m->num);
-}
-/*---------------------------------------------------------------------------*/
-void *
-oc_memb_alloc(struct oc_memb *m)
-{
- int i;
-
- for (i = 0; i < m->num; ++i) {
- if (m->count[i] == 0) {
- /* If this block was unused, we increase the reference count to
- indicate that it now is used and return a pointer to the
- memory block. */
- ++(m->count[i]);
- return (void *)((char *)m->mem + (i * m->size));
- }
- }
-
- /* No free block was found, so we return NULL to indicate failure to
- allocate block. */
- return NULL;
-}
-/*---------------------------------------------------------------------------*/
-char
-oc_memb_free(struct oc_memb *m, void *ptr)
-{
- int i;
- char *ptr2;
-
- /* Walk through the list of blocks and try to find the block to
- which the pointer "ptr" points to. */
- ptr2 = (char *)m->mem;
- for (i = 0; i < m->num; ++i) {
-
- if (ptr2 == (char *)ptr) {
- /* We've found to block to which "ptr" points so we decrease the
- reference count and return the new value of it. */
- if (m->count[i] > 0) {
- /* Make sure that we don't deallocate free memory. */
- --(m->count[i]);
- }
- return m->count[i];
- }
- ptr2 += m->size;
- }
- return -1;
-}
-/*---------------------------------------------------------------------------*/
-int
-oc_memb_inmemb(struct oc_memb *m, void *ptr)
-{
- return (char *)ptr >= (char *)m->mem &&
- (char *)ptr < (char *)m->mem + (m->num * m->size);
-}
-/*---------------------------------------------------------------------------*/
-int
-oc_memb_numfree(struct oc_memb *m)
-{
- int i;
- int num_free = 0;
-
- for (i = 0; i < m->num; ++i) {
- if (m->count[i] == 0) {
- ++num_free;
- }
- }
-
- return num_free;
-}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_memb.h
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_memb.h b/libs/iotivity/src/util/oc_memb.h
deleted file mode 100644
index 37ecca6..0000000
--- a/libs/iotivity/src/util/oc_memb.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2004, Swedish Institute of Computer Science.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- * Author: Adam Dunkels <ad...@sics.se>
- *
- */
-
-/**
- * \defgroup memb Memory block management functions
- *
- * The memory block allocation routines provide a simple yet powerful
- * set of functions for managing a set of memory blocks of fixed
- * size. A set of memory blocks is statically declared with the
- * OC_MEMB() macro. Memory blocks are allocated from the declared
- * memory by the oc_memb_alloc() function, and are deallocated with the
- * oc_memb_free() function.
- *
- */
-
-#ifndef OC_MEMB_H
-#define OC_MEMB_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define CC_CONCAT2(s1, s2) s1##s2
-/**
- * A C preprocessing macro for concatenating two preprocessor tokens.
- *
- * We need use two macros (CC_CONCAT and CC_CONCAT2) in order to allow
- * concatenation of two \#defined macros.
- */
-#define CC_CONCAT(s1, s2) CC_CONCAT2(s1, s2)
-
-/**
- * Declare a memory block.
- *
- * This macro is used to statically declare a block of memory that can
- * be used by the block allocation functions. The macro statically
- * declares a C array with a size that matches the specified number of
- * blocks and their individual sizes.
- *
- * Example:
- \code
- MEMB(connections, struct connection, 16);
- \endcode
- *
- * \param name The name of the memory block (later used with
- * oc_memb_init(), oc_memb_alloc() and oc_memb_free()).
- *
- * \param structure The name of the struct that the memory block holds
- *
- * \param num The total number of memory chunks in the block.
- *
- */
-#define OC_MEMB(name, structure, num) \
- static char CC_CONCAT(name, _memb_count)[num]; \
- static structure CC_CONCAT(name, _memb_mem)[num]; \
- static struct oc_memb name = { sizeof(structure), num, \
- CC_CONCAT(name, _memb_count), \
- (void *)CC_CONCAT(name, _memb_mem) }
-
-struct oc_memb
-{
- unsigned short size;
- unsigned short num;
- char *count;
- void *mem;
-};
-
-/**
- * Initialize a memory block that was declared with MEMB().
- *
- * \param m A memory block previously declared with MEMB().
- */
-void oc_memb_init(struct oc_memb *m);
-
-/**
- * Allocate a memory block from a block of memory declared with MEMB().
- *
- * \param m A memory block previously declared with MEMB().
- */
-void *oc_memb_alloc(struct oc_memb *m);
-
-/**
- * Deallocate a memory block from a memory block previously declared
- * with MEMB().
- *
- * \param m m A memory block previously declared with MEMB().
- *
- * \param ptr A pointer to the memory block that is to be deallocated.
- *
- * \return The new reference count for the memory block (should be 0
- * if successfully deallocated) or -1 if the pointer "ptr" did not
- * point to a legal memory block.
- */
-char oc_memb_free(struct oc_memb *m, void *ptr);
-
-int oc_memb_inmemb(struct oc_memb *m, void *ptr);
-
-int oc_memb_numfree(struct oc_memb *m);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* OC_MEMB_H */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_mmem.c
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_mmem.c b/libs/iotivity/src/util/oc_mmem.c
deleted file mode 100644
index 8a129c6..0000000
--- a/libs/iotivity/src/util/oc_mmem.c
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (c) 2016 Intel Corporation
- *
- * Copyright (c) 2005, Swedish Institute of Computer Science
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- */
-
-#include "oc_mmem.h"
-#include "config.h"
-#include "oc_list.h"
-#include "port/oc_log.h"
-#include <stdint.h>
-#include <string.h>
-
-#if !defined(OC_BYTES_POOL_SIZE) || !defined(OC_INTS_POOL_SIZE) || \
- !defined(OC_DOUBLES_POOL_SIZE)
-#error "Please define byte, int, double pool sizes in config.h"
-#endif /* ...POOL_SIZE */
-
-static double doubles[OC_DOUBLES_POOL_SIZE];
-static int64_t ints[OC_INTS_POOL_SIZE];
-static unsigned char bytes[OC_BYTES_POOL_SIZE];
-static unsigned int avail_bytes, avail_ints, avail_doubles;
-
-OC_LIST(bytes_list);
-OC_LIST(ints_list);
-OC_LIST(doubles_list);
-
-/*---------------------------------------------------------------------------*/
-int
-oc_mmem_alloc(struct oc_mmem *m, unsigned int size, pool pool_type)
-{
- switch (pool_type) {
- case BYTE_POOL:
- if (avail_bytes < size) {
- return 0;
- }
- oc_list_add(bytes_list, m);
- m->ptr = &bytes[OC_BYTES_POOL_SIZE - avail_bytes];
- m->size = size;
- avail_bytes -= size;
- break;
- case INT_POOL:
- if (avail_ints < size) {
- return 0;
- }
- oc_list_add(ints_list, m);
- m->ptr = &ints[OC_INTS_POOL_SIZE - avail_ints];
- m->size = size;
- avail_ints -= size;
- break;
- case DOUBLE_POOL:
- if (avail_doubles < size) {
- return 0;
- }
- oc_list_add(doubles_list, m);
- m->ptr = &doubles[OC_DOUBLES_POOL_SIZE - avail_doubles];
- m->size = size;
- avail_doubles -= size;
- break;
- default:
- break;
- }
- return 1;
-}
-
-void
-oc_mmem_free(struct oc_mmem *m, pool pool_type)
-{
- struct oc_mmem *n;
-
- if (m->next != NULL) {
- switch (pool_type) {
- case BYTE_POOL:
- memmove(m->ptr, m->next->ptr, &bytes[OC_BYTES_POOL_SIZE - avail_bytes] -
- (unsigned char *)m->next->ptr);
- break;
- case INT_POOL:
- memmove(m->ptr, m->next->ptr,
- &ints[OC_INTS_POOL_SIZE - avail_ints] - (int64_t *)m->next->ptr);
- break;
- case DOUBLE_POOL:
- memmove(m->ptr, m->next->ptr,
- &doubles[OC_DOUBLES_POOL_SIZE - avail_doubles] -
- (double *)m->next->ptr);
- break;
- default:
- return;
- break;
- }
- for (n = m->next; n != NULL; n = n->next) {
- n->ptr = (void *)((char *)n->ptr - m->size);
- }
- }
-
- switch (pool_type) {
- case BYTE_POOL:
- avail_bytes += m->size;
- oc_list_remove(bytes_list, m);
- break;
- case INT_POOL:
- avail_ints += m->size;
- oc_list_remove(ints_list, m);
- break;
- case DOUBLE_POOL:
- avail_doubles += m->size;
- oc_list_remove(doubles_list, m);
- break;
- }
-}
-
-void
-oc_mmem_init(void)
-{
- static int inited = 0;
- if (inited) {
- return;
- }
- oc_list_init(bytes_list);
- oc_list_init(ints_list);
- oc_list_init(doubles_list);
- avail_bytes = OC_BYTES_POOL_SIZE;
- avail_ints = OC_INTS_POOL_SIZE;
- avail_doubles = OC_DOUBLES_POOL_SIZE;
- inited = 1;
-}
-/*---------------------------------------------------------------------------*/
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_mmem.h
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_mmem.h b/libs/iotivity/src/util/oc_mmem.h
deleted file mode 100644
index bcd170f..0000000
--- a/libs/iotivity/src/util/oc_mmem.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2016 Intel Corporation
- *
- * Copyright (c) 2005, Swedish Institute of Computer Science
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- */
-
-#ifndef OC_MMEM_H
-#define OC_MMEM_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define OC_MMEM_PTR(m) (struct oc_mmem *)(m)->ptr
-
-struct oc_mmem
-{
- struct oc_mmem *next;
- unsigned int size;
- void *ptr;
-};
-
-typedef enum { BYTE_POOL, INT_POOL, DOUBLE_POOL } pool;
-
-int oc_mmem_alloc(struct oc_mmem *m, unsigned int size, pool pool_type);
-void oc_mmem_free(struct oc_mmem *, pool pool_type);
-void oc_mmem_init(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* OC_MMEM_H */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_process.c
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_process.c b/libs/iotivity/src/util/oc_process.c
deleted file mode 100644
index 47c3282..0000000
--- a/libs/iotivity/src/util/oc_process.c
+++ /dev/null
@@ -1,346 +0,0 @@
-/*
- * Copyright (c) 2016 Intel Corporation
- *
- * Copyright (c) 2005, Swedish Institute of Computer Science
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- */
-
-#include "oc_process.h"
-#include "oc_buffer.h"
-#include <stdio.h>
-
-/*
- * Pointer to the currently running process structure.
- */
-struct oc_process *oc_process_list = NULL;
-struct oc_process *oc_process_current = NULL;
-
-static oc_process_event_t lastevent;
-
-/*
- * Structure used for keeping the queue of active events.
- */
-struct event_data
-{
- oc_process_event_t ev;
- oc_process_data_t data;
- struct oc_process *p;
-};
-
-static oc_process_num_events_t nevents, fevent;
-static struct event_data events[OC_PROCESS_CONF_NUMEVENTS];
-
-#if OC_PROCESS_CONF_STATS
-oc_process_num_events_t process_maxevents;
-#endif
-
-static volatile unsigned char poll_requested;
-
-#define OC_PROCESS_STATE_NONE 0
-#define OC_PROCESS_STATE_RUNNING 1
-#define OC_PROCESS_STATE_CALLED 2
-
-static void call_process(struct oc_process *p, oc_process_event_t ev,
- oc_process_data_t data);
-
-/*---------------------------------------------------------------------------*/
-oc_process_event_t
-oc_process_alloc_event(void)
-{
- return lastevent++;
-}
-/*---------------------------------------------------------------------------*/
-void
-oc_process_start(struct oc_process *p, oc_process_data_t data)
-{
- struct oc_process *q;
-
- /* First make sure that we don't try to start a process that is
- already running. */
- for (q = oc_process_list; q != p && q != NULL; q = q->next)
- ;
-
- /* If we found the process on the process list, we bail out. */
- if (q == p) {
- return;
- }
- /* Put on the procs list.*/
- p->next = oc_process_list;
- oc_process_list = p;
- p->state = OC_PROCESS_STATE_RUNNING;
- PT_INIT(&p->pt);
-
- /* Post a synchronous initialization event to the process. */
- oc_process_post_synch(p, OC_PROCESS_EVENT_INIT, data);
-}
-/*---------------------------------------------------------------------------*/
-static void
-exit_process(struct oc_process *p, struct oc_process *fromprocess)
-{
- register struct oc_process *q;
- struct oc_process *old_current = oc_process_current;
-
- /* Make sure the process is in the process list before we try to
- exit it. */
- for (q = oc_process_list; q != p && q != NULL; q = q->next)
- ;
- if (q == NULL) {
- return;
- }
-
- if (oc_process_is_running(p)) {
- /* Process was running */
- p->state = OC_PROCESS_STATE_NONE;
-
- /*
- * Post a synchronous event to all processes to inform them that
- * this process is about to exit. This will allow services to
- * deallocate state associated with this process.
- */
- for (q = oc_process_list; q != NULL; q = q->next) {
- if (p != q) {
- call_process(q, OC_PROCESS_EVENT_EXITED, (oc_process_data_t)p);
- }
- }
-
- if (p->thread != NULL && p != fromprocess) {
- /* Post the exit event to the process that is about to exit. */
- oc_process_current = p;
- p->thread(&p->pt, OC_PROCESS_EVENT_EXIT, NULL);
- }
- }
-
- if (p == oc_process_list) {
- oc_process_list = oc_process_list->next;
- } else {
- for (q = oc_process_list; q != NULL; q = q->next) {
- if (q->next == p) {
- q->next = p->next;
- break;
- }
- }
- }
-
- oc_process_current = old_current;
-}
-/*---------------------------------------------------------------------------*/
-static void
-call_process(struct oc_process *p, oc_process_event_t ev,
- oc_process_data_t data)
-{
- int ret;
-
- if ((p->state & OC_PROCESS_STATE_RUNNING) && p->thread != NULL) {
- oc_process_current = p;
- p->state = OC_PROCESS_STATE_CALLED;
- ret = p->thread(&p->pt, ev, data);
- if (ret == PT_EXITED || ret == PT_ENDED || ev == OC_PROCESS_EVENT_EXIT) {
- exit_process(p, p);
- } else {
- p->state = OC_PROCESS_STATE_RUNNING;
- }
- }
-}
-/*---------------------------------------------------------------------------*/
-void
-oc_process_exit(struct oc_process *p)
-{
- exit_process(p, OC_PROCESS_CURRENT());
-}
-/*---------------------------------------------------------------------------*/
-void
-oc_process_init(void)
-{
- lastevent = OC_PROCESS_EVENT_MAX;
-
- nevents = fevent = 0;
-#if OC_PROCESS_CONF_STATS
- process_maxevents = 0;
-#endif /* OC_PROCESS_CONF_STATS */
-
- oc_process_current = oc_process_list = NULL;
-}
-/*---------------------------------------------------------------------------*/
-/*
- * Call each process' poll handler.
- */
-/*---------------------------------------------------------------------------*/
-static void
-do_poll(void)
-{
- struct oc_process *p;
-
- poll_requested = 0;
- /* Call the processes that needs to be polled. */
- for (p = oc_process_list; p != NULL; p = p->next) {
- if (p->needspoll) {
- p->state = OC_PROCESS_STATE_RUNNING;
- p->needspoll = 0;
- call_process(p, OC_PROCESS_EVENT_POLL, NULL);
- }
- }
-}
-/*---------------------------------------------------------------------------*/
-/*
- * Process the next event in the event queue and deliver it to
- * listening processes.
- */
-/*---------------------------------------------------------------------------*/
-static void
-do_event(void)
-{
- static oc_process_event_t ev;
- static oc_process_data_t data;
- static struct oc_process *receiver;
- static struct oc_process *p;
-
- /*
- * If there are any events in the queue, take the first one and walk
- * through the list of processes to see if the event should be
- * delivered to any of them. If so, we call the event handler
- * function for the process. We only process one event at a time and
- * call the poll handlers inbetween.
- */
-
- if (nevents > 0) {
-
- /* There are events that we should deliver. */
- ev = events[fevent].ev;
-
- data = events[fevent].data;
- receiver = events[fevent].p;
-
- /* Since we have seen the new event, we move pointer upwards
- and decrease the number of events. */
- fevent = (fevent + 1) % OC_PROCESS_CONF_NUMEVENTS;
- --nevents;
-
- /* If this is a broadcast event, we deliver it to all events, in
- order of their priority. */
- if (receiver == OC_PROCESS_BROADCAST) {
- for (p = oc_process_list; p != NULL; p = p->next) {
-
- /* If we have been requested to poll a process, we do this in
- between processing the broadcast event. */
- if (poll_requested) {
- do_poll();
- }
- call_process(p, ev, data);
- }
- } else {
- /* This is not a broadcast event, so we deliver it to the
- specified process. */
- /* If the event was an INIT event, we should also update the
- state of the process. */
- if (ev == OC_PROCESS_EVENT_INIT) {
- receiver->state = OC_PROCESS_STATE_RUNNING;
- }
-
- /* Make sure that the process actually is running. */
- call_process(receiver, ev, data);
- }
- }
-}
-/*---------------------------------------------------------------------------*/
-int
-oc_process_run(void)
-{
- /* Process poll events. */
- if (poll_requested) {
- do_poll();
- }
-
- /* Process one event from the queue */
- do_event();
-
- return nevents + poll_requested;
-}
-/*---------------------------------------------------------------------------*/
-int
-oc_process_nevents(void)
-{
- return nevents + poll_requested;
-}
-/*---------------------------------------------------------------------------*/
-int
-oc_process_post(struct oc_process *p, oc_process_event_t ev,
- oc_process_data_t data)
-{
- static oc_process_num_events_t snum;
-
- if (nevents == OC_PROCESS_CONF_NUMEVENTS) {
- oc_message_unref(data);
- return OC_PROCESS_ERR_FULL;
- }
-
- snum =
- (oc_process_num_events_t)(fevent + nevents) % OC_PROCESS_CONF_NUMEVENTS;
- events[snum].ev = ev;
- events[snum].data = data;
- events[snum].p = p;
- ++nevents;
-
-#if OC_PROCESS_CONF_STATS
- if (nevents > process_maxevents) {
- process_maxevents = nevents;
- }
-#endif /* OC_PROCESS_CONF_STATS */
-
- return OC_PROCESS_ERR_OK;
-}
-/*---------------------------------------------------------------------------*/
-void
-oc_process_post_synch(struct oc_process *p, oc_process_event_t ev,
- oc_process_data_t data)
-{
- struct oc_process *caller = oc_process_current;
-
- call_process(p, ev, data);
- oc_process_current = caller;
-}
-/*---------------------------------------------------------------------------*/
-void
-oc_process_poll(struct oc_process *p)
-{
- if (p != NULL) {
- if (p->state == OC_PROCESS_STATE_RUNNING ||
- p->state == OC_PROCESS_STATE_CALLED) {
- p->needspoll = 1;
- poll_requested = 1;
- }
- }
-}
-/*---------------------------------------------------------------------------*/
-int
-oc_process_is_running(struct oc_process *p)
-{
- return p->state != OC_PROCESS_STATE_NONE;
-}
-/*---------------------------------------------------------------------------*/
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_process.h
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_process.h b/libs/iotivity/src/util/oc_process.h
deleted file mode 100644
index b81e217..0000000
--- a/libs/iotivity/src/util/oc_process.h
+++ /dev/null
@@ -1,535 +0,0 @@
-/*
- * Copyright (c) 2016 Intel Corporation
- *
- * Copyright (c) 2005, Swedish Institute of Computer Science
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- */
-
-/**
- * \defgroup process Contiki processes
- *
- * A process in Contiki consists of a single \ref pt "protothread".
- *
- * @{
- */
-
-#ifndef OC_PROCESS_H
-#define OC_PROCESS_H
-#include "pt/pt.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef NULL
-#define NULL 0
-#endif /* NULL */
-
-typedef unsigned char oc_process_event_t;
-typedef void *oc_process_data_t;
-typedef unsigned char oc_process_num_events_t;
-
-/**
- * \name Return values
- * @{
- */
-
-/**
- * \brief Return value indicating that an operation was successful.
- *
- * This value is returned to indicate that an operation
- * was successful.
- */
-#define OC_PROCESS_ERR_OK 0
-/**
- * \brief Return value indicating that the event queue was full.
- *
- * This value is returned from process_post() to indicate
- * that the event queue was full and that an event could
- * not be posted.
- */
-#define OC_PROCESS_ERR_FULL 1
-/* @} */
-
-#define OC_PROCESS_NONE NULL
-
-#ifndef OC_PROCESS_CONF_NUMEVENTS
-#define OC_PROCESS_CONF_NUMEVENTS 10
-#endif /* OC_PROCESS_CONF_NUMEVENTS */
-
-#define OC_PROCESS_EVENT_NONE 0x80
-#define OC_PROCESS_EVENT_INIT 0x81
-#define OC_PROCESS_EVENT_POLL 0x82
-#define OC_PROCESS_EVENT_EXIT 0x83
-#define OC_PROCESS_EVENT_SERVICE_REMOVED 0x84
-#define OC_PROCESS_EVENT_CONTINUE 0x85
-#define OC_PROCESS_EVENT_MSG 0x86
-#define OC_PROCESS_EVENT_EXITED 0x87
-#define OC_PROCESS_EVENT_TIMER 0x88
-#define OC_PROCESS_EVENT_COM 0x89
-#define OC_PROCESS_EVENT_MAX 0x8a
-
-#define OC_PROCESS_BROADCAST NULL
-#define OC_PROCESS_ZOMBIE ((struct oc_process *)0x1)
-
-/**
- * \name Process protothread functions
- * @{
- */
-
-/**
- * Define the beginning of a process.
- *
- * This macro defines the beginning of a process, and must always
- * appear in a OC_PROCESS_THREAD() definition. The OC_PROCESS_END() macro
- * must come at the end of the process.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_BEGIN() PT_BEGIN(process_pt)
-
-/**
- * Define the end of a process.
- *
- * This macro defines the end of a process. It must appear in a
- * OC_PROCESS_THREAD() definition and must always be included. The
- * process exits when the OC_PROCESS_END() macro is reached.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_END() PT_END(process_pt)
-
-/**
- * Wait for an event to be posted to the process.
- *
- * This macro blocks the currently running process until the process
- * receives an event.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_WAIT_EVENT() OC_PROCESS_YIELD()
-
-/**
- * Wait for an event to be posted to the process, with an extra
- * condition.
- *
- * This macro is similar to OC_PROCESS_WAIT_EVENT() in that it blocks the
- * currently running process until the process receives an event. But
- * OC_PROCESS_WAIT_EVENT_UNTIL() takes an extra condition which must be
- * true for the process to continue.
- *
- * \param c The condition that must be true for the process to continue.
- * \sa PT_WAIT_UNTIL()
- *
- * \hideinitializer
- */
-#define OC_PROCESS_WAIT_EVENT_UNTIL(c) OC_PROCESS_YIELD_UNTIL(c)
-
-/**
- * Yield the currently running process.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_YIELD() PT_YIELD(process_pt)
-
-/**
- * Yield the currently running process until a condition occurs.
- *
- * This macro is different from OC_PROCESS_WAIT_UNTIL() in that
- * OC_PROCESS_YIELD_UNTIL() is guaranteed to always yield at least
- * once. This ensures that the process does not end up in an infinite
- * loop and monopolizing the CPU.
- *
- * \param c The condition to wait for.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_YIELD_UNTIL(c) PT_YIELD_UNTIL(process_pt, c)
-
-/**
- * Wait for a condition to occur.
- *
- * This macro does not guarantee that the process yields, and should
- * therefore be used with care. In most cases, OC_PROCESS_WAIT_EVENT(),
- * OC_PROCESS_WAIT_EVENT_UNTIL(), OC_PROCESS_YIELD() or
- * OC_PROCESS_YIELD_UNTIL() should be used instead.
- *
- * \param c The condition to wait for.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_WAIT_UNTIL(c) PT_WAIT_UNTIL(process_pt, c)
-#define OC_PROCESS_WAIT_WHILE(c) PT_WAIT_WHILE(process_pt, c)
-
-/**
- * Exit the currently running process.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_EXIT() PT_EXIT(process_pt)
-
-/**
- * Spawn a protothread from the process.
- *
- * \param pt The protothread state (struct pt) for the new protothread
- * \param thread The call to the protothread function.
- * \sa PT_SPAWN()
- *
- * \hideinitializer
- */
-#define OC_PROCESS_PT_SPAWN(pt, thread) PT_SPAWN(process_pt, pt, thread)
-
-/**
- * Yield the process for a short while.
- *
- * This macro yields the currently running process for a short while,
- * thus letting other processes run before the process continues.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_PAUSE() \
- do { \
- process_post(OC_PROCESS_CURRENT(), OC_PROCESS_EVENT_CONTINUE, NULL); \
- OC_PROCESS_WAIT_EVENT_UNTIL(ev == OC_PROCESS_EVENT_CONTINUE); \
- } while (0)
-
-/** @} end of protothread functions */
-
-/**
- * \name Poll and exit handlers
- * @{
- */
-/**
- * Specify an action when a process is polled.
- *
- * \note This declaration must come immediately before the
- * OC_PROCESS_BEGIN() macro.
- *
- * \param handler The action to be performed.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_POLLHANDLER(handler) \
- if (ev == OC_PROCESS_EVENT_POLL) { \
- handler; \
- }
-
-/**
- * Specify an action when a process exits.
- *
- * \note This declaration must come immediately before the
- * OC_PROCESS_BEGIN() macro.
- *
- * \param handler The action to be performed.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_EXITHANDLER(handler) \
- if (ev == OC_PROCESS_EVENT_EXIT) { \
- handler; \
- }
-
-/** @} */
-
-/**
- * \name Process declaration and definition
- * @{
- */
-
-/**
- * Define the body of a process.
- *
- * This macro is used to define the body (protothread) of a
- * process. The process is called whenever an event occurs in the
- * system, A process always start with the OC_PROCESS_BEGIN() macro and
- * end with the OC_PROCESS_END() macro.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_THREAD(name, ev, data) \
- static PT_THREAD(process_thread_##name( \
- struct pt *process_pt, oc_process_event_t ev, oc_process_data_t data))
-
-/**
- * Declare the name of a process.
- *
- * This macro is typically used in header files to declare the name of
- * a process that is implemented in the C file.
- *
- * \hideinitializer
- */
-#define OC_PROCESS_NAME(name) extern struct oc_process name
-
-/**
- * Declare a process.
- *
- * This macro declares a process. The process has two names: the
- * variable of the process structure, which is used by the C program,
- * and a human readable string name, which is used when debugging.
- * A configuration option allows removal of the readable name to save RAM.
- *
- * \param name The variable name of the process structure.
- * \param strname The string representation of the process' name.
- *
- * \hideinitializer
- */
-#if OC_PROCESS_CONF_NO_OC_PROCESS_NAMES
-#define OC_PROCESS(name, strname) \
- OC_PROCESS_THREAD(name, ev, data); \
- struct oc_process name = { NULL, process_thread_##name }
-#else
-#define OC_PROCESS(name, strname) \
- OC_PROCESS_THREAD(name, ev, data); \
- struct oc_process name = { NULL, strname, process_thread_##name }
-#endif
-
-/** @} */
-
-struct oc_process
-{
- struct oc_process *next;
-#if OC_PROCESS_CONF_NO_OC_PROCESS_NAMES
-#define OC_PROCESS_NAME_STRING(process) ""
-#else
- const char *name;
-#define OC_PROCESS_NAME_STRING(process) (process)->name
-#endif
- PT_THREAD((*thread)(struct pt *, oc_process_event_t, oc_process_data_t));
- struct pt pt;
- unsigned char state, needspoll;
-};
-
-/**
- * \name Functions called from application programs
- * @{
- */
-
-/**
- * Start a process.
- *
- * \param p A pointer to a process structure.
- *
- * \param data An argument pointer that can be passed to the new
- * process
- *
- */
-void oc_process_start(struct oc_process *p, oc_process_data_t data);
-
-/**
- * Post an asynchronous event.
- *
- * This function posts an asynchronous event to one or more
- * processes. The handing of the event is deferred until the target
- * process is scheduled by the kernel. An event can be broadcast to
- * all processes, in which case all processes in the system will be
- * scheduled to handle the event.
- *
- * \param ev The event to be posted.
- *
- * \param data The auxiliary data to be sent with the event
- *
- * \param p The process to which the event should be posted, or
- * OC_PROCESS_BROADCAST if the event should be posted to all processes.
- *
- * \retval OC_PROCESS_ERR_OK The event could be posted.
- *
- * \retval OC_PROCESS_ERR_FULL The event queue was full and the event could
- * not be posted.
- */
-int oc_process_post(struct oc_process *p, oc_process_event_t ev,
- oc_process_data_t data);
-
-/**
- * Post a synchronous event to a process.
- *
- * \param p A pointer to the process' process structure.
- *
- * \param ev The event to be posted.
- *
- * \param data A pointer to additional data that is posted together
- * with the event.
- */
-void oc_process_post_synch(struct oc_process *p, oc_process_event_t ev,
- oc_process_data_t data);
-
-/**
- * \brief Cause a process to exit
- * \param p The process that is to be exited
- *
- * This function causes a process to exit. The process can
- * either be the currently executing process, or another
- * process that is currently running.
- *
- * \sa OC_PROCESS_CURRENT()
- */
-void oc_process_exit(struct oc_process *p);
-
-/**
- * Get a pointer to the currently running process.
- *
- * This macro get a pointer to the currently running
- * process. Typically, this macro is used to post an event to the
- * current process with process_post().
- *
- * \hideinitializer
- */
-#define OC_PROCESS_CURRENT() oc_process_current
-extern struct oc_process *oc_process_current;
-
-/**
- * Switch context to another process
- *
- * This function switch context to the specified process and executes
- * the code as if run by that process. Typical use of this function is
- * to switch context in services, called by other processes. Each
- * OC_PROCESS_CONTEXT_BEGIN() must be followed by the
- * OC_PROCESS_CONTEXT_END() macro to end the context switch.
- *
- * Example:
- \code
- OC_PROCESS_CONTEXT_BEGIN(&test_process);
- etimer_set(&timer, CLOCK_SECOND);
- OC_PROCESS_CONTEXT_END(&test_process);
- \endcode
- *
- * \param p The process to use as context
- *
- * \sa OC_PROCESS_CONTEXT_END()
- * \sa OC_PROCESS_CURRENT()
- */
-#define OC_PROCESS_CONTEXT_BEGIN(p) \
- { \
- struct oc_process *tmp_current = OC_PROCESS_CURRENT(); \
- oc_process_current = p
-
-/**
- * End a context switch
- *
- * This function ends a context switch and changes back to the
- * previous process.
- *
- * \param p The process used in the context switch
- *
- * \sa OC_PROCESS_CONTEXT_START()
- */
-#define OC_PROCESS_CONTEXT_END(p) \
- oc_process_current = tmp_current; \
- }
-
-/**
- * \brief Allocate a global event number.
- * \return The allocated event number
- *
- * In Contiki, event numbers above 128 are global and may
- * be posted from one process to another. This function
- * allocates one such event number.
- *
- * \note There currently is no way to deallocate an allocated event
- * number.
- */
-oc_process_event_t oc_process_alloc_event(void);
-
-/** @} */
-
-/**
- * \name Functions called from device drivers
- * @{
- */
-
-/**
- * Request a process to be polled.
- *
- * This function typically is called from an interrupt handler to
- * cause a process to be polled.
- *
- * \param p A pointer to the process' process structure.
- */
-void oc_process_poll(struct oc_process *p);
-
-/** @} */
-
-/**
- * \name Functions called by the system and boot-up code
- * @{
- */
-
-/**
- * \brief Initialize the process module.
- *
- * This function initializes the process module and should
- * be called by the system boot-up code.
- */
-void oc_process_init(void);
-
-/**
- * Run the system once - call poll handlers and process one event.
- *
- * This function should be called repeatedly from the main() program
- * to actually run the Contiki system. It calls the necessary poll
- * handlers, and processes one event. The function returns the number
- * of events that are waiting in the event queue so that the caller
- * may choose to put the CPU to sleep when there are no pending
- * events.
- *
- * \return The number of events that are currently waiting in the
- * event queue.
- */
-int oc_process_run(void);
-
-/**
- * Check if a process is running.
- *
- * This function checks if a specific process is running.
- *
- * \param p The process.
- * \retval Non-zero if the process is running.
- * \retval Zero if the process is not running.
- */
-int oc_process_is_running(struct oc_process *p);
-
-/**
- * Number of events waiting to be processed.
- *
- * \return The number of events that are currently waiting to be
- * processed.
- */
-int oc_process_nevents(void);
-
-/** @} */
-
-extern struct oc_process *oc_process_list;
-
-#define OC_PROCESS_LIST() oc_process_list
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* OC_PROCESS_H */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_timer.c
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_timer.c b/libs/iotivity/src/util/oc_timer.c
deleted file mode 100644
index 5372f0b..0000000
--- a/libs/iotivity/src/util/oc_timer.c
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright (c) 2004, Swedish Institute of Computer Science.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- * Author: Adam Dunkels <ad...@sics.se>
- *
- */
-
-#include "oc_timer.h"
-
-/*---------------------------------------------------------------------------*/
-/**
- * Set a timer.
- *
- * This function is used to set a timer for a time sometime in the
- * future. The function oc_timer_expired() will evaluate to true after
- * the timer has expired.
- *
- * \param t A pointer to the timer
- * \param interval The interval before the timer expires.
- *
- */
-void
-oc_timer_set(struct oc_timer *t, oc_clock_time_t interval)
-{
- t->interval = interval;
- t->start = oc_clock_time();
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Reset the timer with the same interval.
- *
- * This function resets the timer with the same interval that was
- * given to the oc_timer_set() function. The start point of the interval
- * is the exact time that the timer last expired. Therefore, this
- * function will cause the timer to be stable over time, unlike the
- * oc_timer_restart() function.
- *
- * \note Must not be executed before timer expired
- *
- * \param t A pointer to the timer.
- * \sa oc_timer_restart()
- */
-void
-oc_timer_reset(struct oc_timer *t)
-{
- t->start += t->interval;
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Restart the timer from the current point in time
- *
- * This function restarts a timer with the same interval that was
- * given to the oc_timer_set() function. The timer will start at the
- * current time.
- *
- * \note A periodic timer will drift if this function is used to reset
- * it. For preioric timers, use the oc_timer_reset() function instead.
- *
- * \param t A pointer to the timer.
- *
- * \sa oc_timer_reset()
- */
-void
-oc_timer_restart(struct oc_timer *t)
-{
- t->start = oc_clock_time();
-}
-/*---------------------------------------------------------------------------*/
-/**
- * Check if a timer has expired.
- *
- * This function tests if a timer has expired and returns true or
- * false depending on its status.
- *
- * \param t A pointer to the timer
- *
- * \return Non-zero if the timer has expired, zero otherwise.
- *
- */
-int
-oc_timer_expired(struct oc_timer *t)
-{
- /* Note: Can not return diff >= t->interval so we add 1 to diff and return
- t->interval < diff - required to avoid an internal error in mspgcc. */
- oc_clock_time_t diff = (oc_clock_time() - t->start) + 1;
- return t->interval < diff;
-}
-/*---------------------------------------------------------------------------*/
-/**
- * The time until the timer expires
- *
- * This function returns the time until the timer expires.
- *
- * \param t A pointer to the timer
- *
- * \return The time until the timer expires
- *
- */
-oc_clock_time_t
-oc_timer_remaining(struct oc_timer *t)
-{
- return t->start + t->interval - oc_clock_time();
-}
-/*---------------------------------------------------------------------------*/
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/oc_timer.h
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/oc_timer.h b/libs/iotivity/src/util/oc_timer.h
deleted file mode 100644
index fd6c826..0000000
--- a/libs/iotivity/src/util/oc_timer.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (c) 2004, Swedish Institute of Computer Science.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- * Author: Adam Dunkels <ad...@sics.se>
- *
- */
-
-/**
- * \defgroup timer Timer library
- *
- * The Contiki kernel does not provide support for timed
- * events. Rather, an application that wants to use timers needs to
- * explicitly use the timer library.
- *
- * The timer library provides functions for setting, resetting and
- * restarting timers, and for checking if a timer has expired. An
- * application must "manually" check if its timers have expired; this
- * is not done automatically.
- *
- * A timer is declared as a \c struct \c timer and all access to the
- * timer is made by a pointer to the declared timer.
- *
- * \note The timer library is not able to post events when a timer
- * expires. The \ref etimer "Event timers" should be used for this
- * purpose.
- *
- * \note The timer library uses the \ref clock "Clock library" to
- * measure time. Intervals should be specified in the format used by
- * the clock library.
- *
- * \sa \ref etimer "Event timers"
- *
- * @{
- */
-
-#ifndef OC_TIMER_H
-#define OC_TIMER_H
-
-#include "../port/oc_clock.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * A timer.
- *
- * This structure is used for declaring a timer. The timer must be set
- * with timer_set() before it can be used.
- *
- * \hideinitializer
- */
-struct oc_timer
-{
- oc_clock_time_t start;
- oc_clock_time_t interval;
-};
-
-void oc_timer_set(struct oc_timer *t, oc_clock_time_t interval);
-void oc_timer_reset(struct oc_timer *t);
-void oc_timer_restart(struct oc_timer *t);
-int oc_timer_expired(struct oc_timer *t);
-oc_clock_time_t oc_timer_remaining(struct oc_timer *t);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* OC_TIMER_H */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/pt/lc-addrlabels.h
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/pt/lc-addrlabels.h b/libs/iotivity/src/util/pt/lc-addrlabels.h
deleted file mode 100644
index 68a043e..0000000
--- a/libs/iotivity/src/util/pt/lc-addrlabels.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2004-2005, Swedish Institute of Computer Science.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- * Author: Adam Dunkels <ad...@sics.se>
- *
- */
-
-/**
- * \addtogroup lc
- * @{
- */
-
-/**
- * \file
- * Implementation of local continuations based on the "Labels as
- * values" feature of gcc
- * \author
- * Adam Dunkels <ad...@sics.se>
- *
- * This implementation of local continuations is based on a special
- * feature of the GCC C compiler called "labels as values". This
- * feature allows assigning pointers with the address of the code
- * corresponding to a particular C label.
- *
- * For more information, see the GCC documentation:
- * http://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html
- *
- * Thanks to dividuum for finding the nice local scope label
- * implementation.
- */
-
-#ifndef LC_ADDRLABELS_H_
-#define LC_ADDRLABELS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** \hideinitializer */
-typedef void *lc_t;
-
-#define LC_INIT(s) s = NULL
-
-#define LC_RESUME(s) \
- do { \
- if (s != NULL) { \
- goto *s; \
- } \
- } while (0)
-
-#define LC_SET(s) \
- do { \
- ({ \
- __label__ resume; \
- resume: \
- (s) = &&resume; \
- }); \
- } while (0)
-
-#define LC_END(s)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LC_ADDRLABELS_H_ */
-/** @} */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/pt/lc-switch.h
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/pt/lc-switch.h b/libs/iotivity/src/util/pt/lc-switch.h
deleted file mode 100644
index 7521c25..0000000
--- a/libs/iotivity/src/util/pt/lc-switch.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 2004-2005, Swedish Institute of Computer Science.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- * Author: Adam Dunkels <ad...@sics.se>
- *
- */
-
-/**
- * \addtogroup lc
- * @{
- */
-
-/**
- * \file
- * Implementation of local continuations based on switch() statement
- * \author Adam Dunkels <ad...@sics.se>
- *
- * This implementation of local continuations uses the C switch()
- * statement to resume execution of a function somewhere inside the
- * function's body. The implementation is based on the fact that
- * switch() statements are able to jump directly into the bodies of
- * control structures such as if() or while() statements.
- *
- * This implementation borrows heavily from Simon Tatham's coroutines
- * implementation in C:
- * http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
- */
-
-#ifndef LC_SWITCH_H_
-#define LC_SWITCH_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* WARNING! lc implementation using switch() does not work if an
- LC_SET() is done within another switch() statement! */
-
-/** \hideinitializer */
-typedef unsigned short lc_t;
-
-#define LC_INIT(s) s = 0;
-
-#define LC_RESUME(s) \
- switch (s) { \
- case 0:
-
-#define LC_SET(s) \
- s = __LINE__; \
- case __LINE__:
-
-#define LC_END(s) }
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LC_SWITCH_H_ */
-
-/** @} */
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-core/blob/f88168c2/libs/iotivity/src/util/pt/lc.h
----------------------------------------------------------------------
diff --git a/libs/iotivity/src/util/pt/lc.h b/libs/iotivity/src/util/pt/lc.h
deleted file mode 100644
index 1d2c254..0000000
--- a/libs/iotivity/src/util/pt/lc.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (c) 2004-2005, Swedish Institute of Computer Science.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the Institute nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * This file is part of the Contiki operating system.
- *
- * Author: Adam Dunkels <ad...@sics.se>
- *
- */
-
-/**
- * \addtogroup pt
- * @{
- */
-
-/**
- * \defgroup lc Local continuations
- * @{
- *
- * Local continuations form the basis for implementing protothreads. A
- * local continuation can be <i>set</i> in a specific function to
- * capture the state of the function. After a local continuation has
- * been set can be <i>resumed</i> in order to restore the state of the
- * function at the point where the local continuation was set.
- *
- *
- */
-
-/**
- * \file core/sys/lc.h
- * Local continuations
- * \author
- * Adam Dunkels <ad...@sics.se>
- *
- */
-
-#ifdef DOXYGEN
-/**
- * Initialize a local continuation.
- *
- * This operation initializes the local continuation, thereby
- * unsetting any previously set continuation state.
- *
- * \hideinitializer
- */
-#define LC_INIT(lc)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Set a local continuation.
- *
- * The set operation saves the state of the function at the point
- * where the operation is executed. As far as the set operation is
- * concerned, the state of the function does <b>not</b> include the
- * call-stack or local (automatic) variables, but only the program
- * counter and such CPU registers that needs to be saved.
- *
- * \hideinitializer
- */
-#define LC_SET(lc)
-
-/**
- * Resume a local continuation.
- *
- * The resume operation resumes a previously set local continuation, thus
- * restoring the state in which the function was when the local
- * continuation was set. If the local continuation has not been
- * previously set, the resume operation does nothing.
- *
- * \hideinitializer
- */
-#define LC_RESUME(lc)
-
-/**
- * Mark the end of local continuation usage.
- *
- * The end operation signifies that local continuations should not be
- * used any more in the function. This operation is not needed for
- * most implementations of local continuation, but is required by a
- * few implementations.
- *
- * \hideinitializer
- */
-#define LC_END(lc)
-
-/**
- * \var typedef lc_t;
- *
- * The local continuation type.
- *
- * \hideinitializer
- */
-#endif /* DOXYGEN */
-
-#ifndef LC_H_
-#define LC_H_
-
-#ifdef LC_CONF_INCLUDE
-#include LC_CONF_INCLUDE
-#else /* LC_CONF_INCLUDE */
-#include "lc-switch.h"
-#endif /* LC_CONF_INCLUDE */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LC_H_ */
-
-/** @} */
-/** @} */