contiki list 链表

1 相关宏和数据结构

1.1 LIST_CONCAT

#define LIST_CONCAT2(s1, s2) s1##s2
#define LIST_CONCAT(s1, s2) LIST_CONCAT2(s1, s2)

该宏的作用非常简单,将s1,s2拼接在一起。其中,##起连接作用,编译器在预处理时负责将s1,s2连接在一起。比如hello_##world经过编译器预处理后就变成了hello_world了。

1.2 LIST

typedef void ** list_t;

#define LIST(name)          static void *LIST_CONCAT(name,_list) = NULL;          static list_t name = (list_t)&LIST_CONCAT(name,_list)

经过宏替换后,变为

#define LIST(name)          static void *name_list = NULL;          static list_t name = (list_t)&name_list

该宏用于申明一个链表。可以将name_list理解为链表头(且该表头元素是一个指针),将name理解为一个指向链表头的指针。需要注意的是,name_list所指向的类型必须是一个结构体。

1.3 LIST_STRUCT

#define LIST_STRUCT(name)          void *LIST_CONCAT(name,_list);          list_t name

1.4 LIST_STRUCT_INIT

#define LIST_STRUCT_INIT(struct_ptr, name)                                  do {                                                                       (struct_ptr)->name = &((struct_ptr)->LIST_CONCAT(name,_list));          (struct_ptr)->LIST_CONCAT(name,_list) = NULL;                           list_init((struct_ptr)->name);                                       } while(0)

1.5 struct list

struct list {
  struct list *next;
};

struct list只有一个指针成员next,它指向的类型依然是struct list。在Contiki中,该结构体用于用于遍历链表,我们将在后面的链表函数中看到如何使用该结构体。

2 各链表函数

2.1 list_init

void
list_init(list_t list)
{
  *list = NULL;
}

作用:初始化链表
解释

2.2 list_head

void *
list_head(list_t list)
{
  return *list;
}

作用:获取链表头
解释

2.3 list_copy

void
list_copy(list_t dest, list_t src)
{
  *dest = *src;
}

作用:“拷贝”链表
解释

2.4 list_tail

void *
list_tail(list_t list)
{
  struct list *l;

  if(*list == NULL) {
    return NULL;
  }

  for(l = *list; l->next != NULL; l = l->next);

  return l;
}

作用:返回链表尾部节点
解释

2.5 list_add

void
list_add(list_t list, void *item)
{
  struct list *l;

  /* Make sure not to add the same element twice */
  list_remove(list, item);

  ((struct list *)item)->next = NULL;

  l = list_tail(list);

  if(l == NULL) {
    *list = item;
  } else {
    l->next = item;
  }
}

作用:在链表尾部加入节点
解释

2.6 list_push

void
list_push(list_t list, void *item)
{
  /*  struct list *l;*/

  /* Make sure not to add the same element twice */
  list_remove(list, item);

  ((struct list *)item)->next = *list;
  *list = item;
}

作用:在链表头部压入节点
解释

2.7 list_chop

void *
list_chop(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;
}

作用:砍掉链表尾部节点,并返回该尾部节点
解释

2.8 list_pop

void *
list_pop(list_t list)
{
  struct list *l;
  l = *list;
  if(*list != NULL) {
    *list = ((struct list *)*list)->next;
  }

  return l;
}

作用弹出链表头结点
解释

2.9 list_remove

void
list_remove(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;
  }
}

作用:删除item所指向的节点

解释

2.10 list_length

int
list_length(list_t list)
{
  struct list *l;
  int n = 0;

  for(l = *list; l != NULL; l = l->next) {
    ++n;
  }

  return n;
}

作用:返回链表长度
解释

2.11 list_insert

void
list_insert(list_t list, void *previtem, void *newitem)
{
  if(previtem == NULL) {
    list_push(list, newitem);
  } else {

    ((struct list *)newitem)->next = ((struct list *)previtem)->next;
    ((struct list *)previtem)->next = newitem;
  }
}

作用:插入链表节点
解释

2.12 list_item_next

void *
list_item_next(void *item)
{
  return item == NULL? NULL: ((struct list *)item)->next;
}

作用:返回链表中item的下一个节点

时间: 07-04

contiki list 链表的相关文章

Contiki Process概述

本文涉及到的Protothread机制知识,在http://www.cnblogs.com/songdechiu/p/5793717.html 进程类型 进程类型主要有协同式(cooperative)和抢占式(preemptive)两种. 协同式进程,要等其他进程运行完进程实体函数(进程不一定运行完,这个时候有可能是阻塞,总之只要执行到return语句,具体看protothread机制),然后才能开始运行. 抢占式进程,会优先运行,当有抢占式进程需要执行时,协同式进程将会被挂起,直到抢占式进程实

简单的玩玩etimer <contiki学习笔记之九 补充>

这幅图片是对前面  <<contiki学习笔记之九>>  的一个补充说明. 简单的玩玩etimer <contiki学习笔记之九> 或许,自己正在掀开contiki process最后的一层面纱: 或许,还有一段路要走: 或许,已经掀开... --------------- 一切,都只是process:只有有了process,才会轮到etimer_process  发言,除非,抛却一切机制,裸机实现etimer... process,是什么? 一个链表,还是单向的,仅此

[Contiki系列论文之4]ContikiMAC RDC协议

目录 目录 摘要 介绍 ContikiMAC 1 ContikiMAC时序 2 包检测和快速睡眠 3锁相传输 实现 评估 1 微观基准 2 网络功率消耗 相关工作 总结 参考文献 摘要 为了降低系统功耗,低功耗无线设备必须尽可能地将无线电收发器关闭,但是为了接收来自邻居节点的通信消息,它必须被经常唤醒.本论文描述了ContikiMAC RDC(Radio-Duty-Cycling)机制,该机制通过使用一系列时序限制,从而达到既关闭收发器又能高效唤醒的作用.在ContikiMAC机制的作用下,参与

PROCESS_YIELD()宏使用及过程分析&lt;contiki学习笔记之八&gt;

好吧,昨晚上研究了switch()的底层实现原理--发现它并不是一般C语言教科书上那样所言,当然,这对于本身就非常熟悉汇编的同学来说,是小菜一碟.世界上,很多事情是巧合与必然的结合体,没有无缘无故的爱,也没有无缘无故的恨---我为啥会被一个switch给挡出去路?这个switch在contiki中又有何重要作用?且不回答这个问题,先来看看如何使用昨天晚上展开的PROCESS_YIELD()宏. 说明:这里就只是贴打印信息,分析打印信息了,不再贴分析过程中的代码了. 一,修改自己的hello-wo

Contiki教程——进程

概述 Contiki中的代码可以运行在下列两种执行上下文之一:合作式或者抢占式.合作式代码按顺序运行,抢占式代码可以暂停正在运行的合作式代码.Contiki中的进程运行在合作式上下文中,而中断和实时定时器运行在抢占式上下文中. 所有的Contiki程序都被叫做进程.一个进程是Contiki系统中被常规执行的一个代码片段.当系统启动时,或者一个包含进程的模块被加载到系统中时,进程开始运行.当一些事发生时,进程会运行,比如一个定时器到期了,或者有一个外部事件产生. Contiki中的代码可以运行在下

contiki系统分析:时钟

contiki系统提供了一系列的时钟库,可以供contiki系统或者用户态的程序调用. 时钟库包括时钟到期检查.在调度时钟时低功耗的模块被唤醒,实时的任务调度. 定时器也可以让执行具体的事情过程中进入休眼状态. contiki的定时器的种类 contiki包抱一个时钟模块,但是有多个时钟模型:timer, stimer, ctimer, etimer, rtimer.不同的时钟有不同的作用.有的定时器运行时间长,但是间隔时间短,有的间隔时间长,但是运行时间短.有些能用于中断的上下文中(rtime

contiki-main.c 中的process系列函数学习笔记 &lt;contiki学习笔记之六&gt;

说明:本文依然依赖于 contiki/platform/native/contiki-main.c 文件. ------------------------------------------------------------------------------------------------------------------------------------- 根据上一个笔记里面添加的printf()语句的打印信息提示,hello world 打印是在执行了 1 autostart_

c语言动态链表的创建

创建动态连链表就是将一个个节点连接起来 (1)动态生成节点 (2)输入节点数据 (3)将节点链在一起 例: typedef struct Data { char num[20]; char name[10]; char sex; float english; float chinese; float math; }; typedef struct Node { struct Data data;//结构体类型//结构体嵌套 struct Node* next;//结构体指针型 }node,*Pn

算法学习——单链表快排

/**  * 以p为轴对start-end间的节点进行快排(包括start && 不包括end):  * 思路:  * 1.将头节点作为轴节点start,从start.next开始遍历,如果节点小于轴start的值,将该节点插入到轴节点后面:  * 2.将轴节点插入合适位置,即找到最后一个小于轴的节点,将该节点与轴节点值互换,此时就链表分为两部分,小于轴节点和大于轴节点:  * 3.递归的遍历2中两部分节点.  *   * @param p  * @param start  * @para