PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - Zend - zend_llist.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 104 142 73.2 %
Date: 2016-02-09 Functions: 17 19 89.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend Engine                                                          |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2016 Zend Technologies Ltd. (http://www.zend.com) |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 2.00 of the Zend license,     |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.zend.com/license/2_00.txt.                                |
      11             :    | If you did not receive a copy of the Zend license and are unable to  |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@zend.com so we can mail you a copy immediately.              |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Andi Gutmans <andi@zend.com>                                |
      16             :    |          Zeev Suraski <zeev@zend.com>                                |
      17             :    +----------------------------------------------------------------------+
      18             : */
      19             : 
      20             : /* $Id$ */
      21             : 
      22             : #include "zend.h"
      23             : #include "zend_llist.h"
      24             : #include "zend_sort.h"
      25             : 
      26      164465 : ZEND_API void zend_llist_init(zend_llist *l, size_t size, llist_dtor_func_t dtor, unsigned char persistent)
      27             : {
      28      164465 :         l->head  = NULL;
      29      164465 :         l->tail  = NULL;
      30      164465 :         l->count = 0;
      31      164465 :         l->size  = size;
      32      164465 :         l->dtor  = dtor;
      33      164465 :         l->persistent = persistent;
      34      164465 : }
      35             : 
      36      102917 : ZEND_API void zend_llist_add_element(zend_llist *l, void *element)
      37             : {
      38      102917 :         zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent);
      39             : 
      40      102917 :         tmp->prev = l->tail;
      41      102917 :         tmp->next = NULL;
      42      102917 :         if (l->tail) {
      43        1691 :                 l->tail->next = tmp;
      44             :         } else {
      45      101226 :                 l->head = tmp;
      46             :         }
      47      102917 :         l->tail = tmp;
      48      102917 :         memcpy(tmp->data, element, l->size);
      49             : 
      50      102917 :         ++l->count;
      51      102917 : }
      52             : 
      53             : 
      54           0 : ZEND_API void zend_llist_prepend_element(zend_llist *l, void *element)
      55             : {
      56           0 :         zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent);
      57             : 
      58           0 :         tmp->next = l->head;
      59           0 :         tmp->prev = NULL;
      60           0 :         if (l->head) {
      61           0 :                 l->head->prev = tmp;
      62             :         } else {
      63           0 :                 l->tail = tmp;
      64             :         }
      65           0 :         l->head = tmp;
      66           0 :         memcpy(tmp->data, element, l->size);
      67             : 
      68           0 :         ++l->count;
      69           0 : }
      70             : 
      71             : 
      72             : #define DEL_LLIST_ELEMENT(current, l) \
      73             :                         if ((current)->prev) {\
      74             :                                 (current)->prev->next = (current)->next;\
      75             :                         } else {\
      76             :                                 (l)->head = (current)->next;\
      77             :                         }\
      78             :                         if ((current)->next) {\
      79             :                                 (current)->next->prev = (current)->prev;\
      80             :                         } else {\
      81             :                                 (l)->tail = (current)->prev;\
      82             :                         }\
      83             :                         if ((l)->dtor) {\
      84             :                                 (l)->dtor((current)->data);\
      85             :                         }\
      86             :                         pefree((current), (l)->persistent);\
      87             :                         --l->count;
      88             : 
      89             : 
      90       53954 : ZEND_API void zend_llist_del_element(zend_llist *l, void *element, int (*compare)(void *element1, void *element2))
      91             : {
      92       53954 :         zend_llist_element *current=l->head;
      93             : 
      94      129981 :         while (current) {
      95       53927 :                 if (compare(current->data, element)) {
      96       31854 :                         DEL_LLIST_ELEMENT(current, l);
      97       31854 :                         break;
      98             :                 }
      99       22073 :                 current = current->next;
     100             :         }
     101       53954 : }
     102             : 
     103             : 
     104      345248 : ZEND_API void zend_llist_destroy(zend_llist *l)
     105             : {
     106      345248 :         zend_llist_element *current=l->head, *next;
     107             : 
     108      761510 :         while (current) {
     109       71014 :                 next = current->next;
     110       71014 :                 if (l->dtor) {
     111       48390 :                         l->dtor(current->data);
     112             :                 }
     113       71014 :                 pefree(current, l->persistent);
     114       71014 :                 current = next;
     115             :         }
     116             : 
     117      345248 :         l->count = 0;
     118      345248 : }
     119             : 
     120             : 
     121      186916 : ZEND_API void zend_llist_clean(zend_llist *l)
     122             : {
     123      186916 :         zend_llist_destroy(l);
     124      186916 :         l->head = l->tail = NULL;
     125      186916 : }
     126             : 
     127             : 
     128         106 : ZEND_API void zend_llist_remove_tail(zend_llist *l)
     129             : {
     130         106 :         zend_llist_element *old_tail = l->tail;
     131         106 :         if (!old_tail) {
     132           0 :                 return;
     133             :         }
     134             : 
     135         106 :         if (old_tail->prev) {
     136         106 :                 old_tail->prev->next = NULL;
     137             :         } else {
     138           0 :                 l->head = NULL;
     139             :         }
     140             : 
     141         106 :         l->tail = old_tail->prev;
     142         106 :         --l->count;
     143             : 
     144         106 :         if (l->dtor) {
     145           0 :                 l->dtor(old_tail->data);
     146             :         }
     147         106 :         pefree(old_tail, l->persistent);
     148             : }
     149             : 
     150             : 
     151           1 : ZEND_API void zend_llist_copy(zend_llist *dst, zend_llist *src)
     152             : {
     153             :         zend_llist_element *ptr;
     154             : 
     155           1 :         zend_llist_init(dst, src->size, src->dtor, src->persistent);
     156           1 :         ptr = src->head;
     157           2 :         while (ptr) {
     158           0 :                 zend_llist_add_element(dst, ptr->data);
     159           0 :                 ptr = ptr->next;
     160             :         }
     161           1 : }
     162             : 
     163             : 
     164       22570 : ZEND_API void zend_llist_apply_with_del(zend_llist *l, int (*func)(void *data))
     165             : {
     166             :         zend_llist_element *element, *next;
     167             : 
     168       22570 :         element=l->head;
     169       67537 :         while (element) {
     170       22397 :                 next = element->next;
     171       22397 :                 if (func(element->data)) {
     172           0 :                         DEL_LLIST_ELEMENT(element, l);
     173             :                 }
     174       22397 :                 element = next;
     175             :         }
     176       22570 : }
     177             : 
     178             : 
     179      112855 : ZEND_API void zend_llist_apply(zend_llist *l, llist_apply_func_t func)
     180             : {
     181             :         zend_llist_element *element;
     182             : 
     183      202540 :         for (element=l->head; element; element=element->next) {
     184       89685 :                 func(element->data);
     185             :         }
     186      112855 : }
     187             : 
     188           0 : static void zend_llist_swap(zend_llist_element **p, zend_llist_element **q)
     189             : {
     190             :         zend_llist_element *t;
     191           0 :         t = *p;
     192           0 :         *p = *q;
     193           0 :         *q = t;
     194           0 : }
     195             : 
     196           1 : ZEND_API void zend_llist_sort(zend_llist *l, llist_compare_func_t comp_func)
     197             : {
     198             :         size_t i;
     199             : 
     200             :         zend_llist_element **elements;
     201             :         zend_llist_element *element, **ptr;
     202             : 
     203           1 :         if (l->count <= 0) {
     204           1 :                 return;
     205             :         }
     206             : 
     207           0 :         elements = (zend_llist_element **) emalloc(l->count * sizeof(zend_llist_element *));
     208             : 
     209           0 :         ptr = &elements[0];
     210             : 
     211           0 :         for (element=l->head; element; element=element->next) {
     212           0 :                 *ptr++ = element;
     213             :         }
     214             : 
     215           0 :         zend_sort(elements, l->count, sizeof(zend_llist_element *),
     216             :                         (compare_func_t) comp_func, (swap_func_t) zend_llist_swap);
     217             : 
     218           0 :         l->head = elements[0];
     219           0 :         elements[0]->prev = NULL;
     220             : 
     221           0 :         for (i = 1; i < l->count; i++) {
     222           0 :                 elements[i]->prev = elements[i-1];
     223           0 :                 elements[i-1]->next = elements[i];
     224             :         }
     225           0 :         elements[i-1]->next = NULL;
     226           0 :         l->tail = elements[i-1];
     227           0 :         efree(elements);
     228             : }
     229             : 
     230             : 
     231          47 : ZEND_API void zend_llist_apply_with_argument(zend_llist *l, llist_apply_with_arg_func_t func, void *arg)
     232             : {
     233             :         zend_llist_element *element;
     234             : 
     235         138 :         for (element=l->head; element; element=element->next) {
     236          91 :                 func(element->data, arg);
     237             :         }
     238          47 : }
     239             : 
     240             : 
     241       22397 : ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func, int num_args, ...)
     242             : {
     243             :         zend_llist_element *element;
     244             :         va_list args;
     245             : 
     246       22397 :         va_start(args, num_args);
     247       22397 :         for (element=l->head; element; element=element->next) {
     248           0 :                 func(element->data, num_args, args);
     249             :         }
     250       22397 :         va_end(args);
     251       22397 : }
     252             : 
     253             : 
     254         444 : ZEND_API size_t zend_llist_count(zend_llist *l)
     255             : {
     256         444 :         return l->count;
     257             : }
     258             : 
     259             : 
     260        1578 : ZEND_API void *zend_llist_get_first_ex(zend_llist *l, zend_llist_position *pos)
     261             : {
     262        1578 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     263             : 
     264        1578 :         *current = l->head;
     265        1578 :         if (*current) {
     266        1553 :                 return (*current)->data;
     267             :         } else {
     268          25 :                 return NULL;
     269             :         }
     270             : }
     271             : 
     272             : 
     273       22309 : ZEND_API void *zend_llist_get_last_ex(zend_llist *l, zend_llist_position *pos)
     274             : {
     275       22309 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     276             : 
     277       22309 :         *current = l->tail;
     278       22309 :         if (*current) {
     279       22309 :                 return (*current)->data;
     280             :         } else {
     281           0 :                 return NULL;
     282             :         }
     283             : }
     284             : 
     285             : 
     286        2714 : ZEND_API void *zend_llist_get_next_ex(zend_llist *l, zend_llist_position *pos)
     287             : {
     288        2714 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     289             : 
     290        2714 :         if (*current) {
     291        2714 :                 *current = (*current)->next;
     292        2714 :                 if (*current) {
     293        1298 :                         return (*current)->data;
     294             :                 }
     295             :         }
     296        1416 :         return NULL;
     297             : }
     298             : 
     299             : 
     300           5 : ZEND_API void *zend_llist_get_prev_ex(zend_llist *l, zend_llist_position *pos)
     301             : {
     302           5 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     303             : 
     304           5 :         if (*current) {
     305           5 :                 *current = (*current)->prev;
     306           5 :                 if (*current) {
     307           0 :                         return (*current)->data;
     308             :                 }
     309             :         }
     310           5 :         return NULL;
     311             : }
     312             : 
     313             : /*
     314             :  * Local variables:
     315             :  * tab-width: 4
     316             :  * c-basic-offset: 4
     317             :  * indent-tabs-mode: t
     318             :  * End:
     319             :  */

Generated by: LCOV version 1.10

Generated at Tue, 09 Feb 2016 10:48:37 +0000 (4 days ago)

Copyright © 2005-2016 The PHP Group
All rights reserved.