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: 98 137 71.5 %
Date: 2014-09-19 Functions: 16 18 88.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend Engine                                                          |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2014 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_qsort.h"
      25             : 
      26      148914 : ZEND_API void zend_llist_init(zend_llist *l, size_t size, llist_dtor_func_t dtor, unsigned char persistent)
      27             : {
      28      148914 :         l->head  = NULL;
      29      148914 :         l->tail  = NULL;
      30      148914 :         l->count = 0;
      31      148914 :         l->size  = size;
      32      148914 :         l->dtor  = dtor;
      33      148914 :         l->persistent = persistent;
      34      148914 : }
      35             : 
      36             : 
      37       92438 : ZEND_API void zend_llist_add_element(zend_llist *l, void *element)
      38             : {
      39       92438 :         zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent);
      40             : 
      41       92438 :         tmp->prev = l->tail;
      42       92438 :         tmp->next = NULL;
      43       92438 :         if (l->tail) {
      44        1694 :                 l->tail->next = tmp;
      45             :         } else {
      46       90744 :                 l->head = tmp;
      47             :         }
      48       92438 :         l->tail = tmp;
      49       92438 :         memcpy(tmp->data, element, l->size);
      50             : 
      51       92438 :         ++l->count;
      52       92438 : }
      53             : 
      54             : 
      55           0 : ZEND_API void zend_llist_prepend_element(zend_llist *l, void *element)
      56             : {
      57           0 :         zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent);
      58             : 
      59           0 :         tmp->next = l->head;
      60           0 :         tmp->prev = NULL;
      61           0 :         if (l->head) {
      62           0 :                 l->head->prev = tmp;
      63             :         } else {
      64           0 :                 l->tail = tmp;
      65             :         }
      66           0 :         l->head = tmp;
      67           0 :         memcpy(tmp->data, element, l->size);
      68             : 
      69           0 :         ++l->count;
      70           0 : }
      71             : 
      72             : 
      73             : #define DEL_LLIST_ELEMENT(current, l) \
      74             :                         if ((current)->prev) {\
      75             :                                 (current)->prev->next = (current)->next;\
      76             :                         } else {\
      77             :                                 (l)->head = (current)->next;\
      78             :                         }\
      79             :                         if ((current)->next) {\
      80             :                                 (current)->next->prev = (current)->prev;\
      81             :                         } else {\
      82             :                                 (l)->tail = (current)->prev;\
      83             :                         }\
      84             :                         if ((l)->dtor) {\
      85             :                                 (l)->dtor((current)->data);\
      86             :                         }\
      87             :                         pefree((current), (l)->persistent);\
      88             :                         --l->count;
      89             : 
      90             : 
      91       48023 : ZEND_API void zend_llist_del_element(zend_llist *l, void *element, int (*compare)(void *element1, void *element2))
      92             : {
      93       48023 :         zend_llist_element *current=l->head;
      94             : 
      95      115909 :         while (current) {
      96       48022 :                 if (compare(current->data, element)) {
      97       28159 :                         DEL_LLIST_ELEMENT(current, l);
      98       28159 :                         break;
      99             :                 }
     100       19863 :                 current = current->next;
     101             :         }
     102       48023 : }
     103             : 
     104             : 
     105      328806 : ZEND_API void zend_llist_destroy(zend_llist *l)
     106             : {
     107      328806 :         zend_llist_element *current=l->head, *next;
     108             :         
     109      721841 :         while (current) {
     110       64229 :                 next = current->next;
     111       64229 :                 if (l->dtor) {
     112       43843 :                         l->dtor(current->data);
     113             :                 }
     114       64229 :                 pefree(current, l->persistent);
     115       64229 :                 current = next;
     116             :         }
     117             : 
     118      328806 :         l->count = 0;
     119      328806 : }
     120             : 
     121             : 
     122      186193 : ZEND_API void zend_llist_clean(zend_llist *l)
     123             : {
     124      186193 :         zend_llist_destroy(l);
     125      186193 :         l->head = l->tail = NULL;
     126      186193 : }
     127             : 
     128             : 
     129         106 : ZEND_API void zend_llist_remove_tail(zend_llist *l)
     130             : {
     131         106 :         zend_llist_element *old_tail = l->tail;
     132         106 :         if (!old_tail) {
     133           0 :                 return;
     134             :         }
     135             : 
     136         106 :         if (old_tail->prev) {
     137         106 :                 old_tail->prev->next = NULL;
     138             :         } else {
     139           0 :                 l->head = NULL;
     140             :         }
     141             : 
     142         106 :         l->tail = old_tail->prev;
     143         106 :         --l->count;
     144             :         
     145         106 :         if (l->dtor) {
     146           0 :                 l->dtor(old_tail->data);
     147             :         }
     148         106 :         pefree(old_tail, l->persistent);
     149             : }
     150             : 
     151             : 
     152           1 : ZEND_API void zend_llist_copy(zend_llist *dst, zend_llist *src)
     153             : {
     154             :         zend_llist_element *ptr;
     155             : 
     156           1 :         zend_llist_init(dst, src->size, src->dtor, src->persistent);
     157           1 :         ptr = src->head;
     158           2 :         while (ptr) {
     159           0 :                 zend_llist_add_element(dst, ptr->data);
     160           0 :                 ptr = ptr->next;
     161             :         }
     162           1 : }
     163             : 
     164             : 
     165       20335 : ZEND_API void zend_llist_apply_with_del(zend_llist *l, int (*func)(void *data))
     166             : {
     167             :         zend_llist_element *element, *next;
     168             : 
     169       20335 :         element=l->head;
     170       60850 :         while (element) {
     171       20180 :                 next = element->next;
     172       20180 :                 if (func(element->data)) {
     173           0 :                         DEL_LLIST_ELEMENT(element, l);
     174             :                 }
     175       20180 :                 element = next;
     176             :         }
     177       20335 : }
     178             : 
     179             : 
     180      101680 : ZEND_API void zend_llist_apply(zend_llist *l, llist_apply_func_t func TSRMLS_DC)
     181             : {
     182             :         zend_llist_element *element;
     183             : 
     184      182490 :         for (element=l->head; element; element=element->next) {
     185       80810 :                 func(element->data TSRMLS_CC);
     186             :         }
     187      101680 : }
     188             : 
     189           1 : ZEND_API void zend_llist_sort(zend_llist *l, llist_compare_func_t comp_func TSRMLS_DC)
     190             : {
     191             :         size_t i;
     192             : 
     193             :         zend_llist_element **elements;
     194             :         zend_llist_element *element, **ptr;
     195             : 
     196           1 :         if (l->count <= 0) {
     197           1 :                 return;
     198             :         }
     199             : 
     200           0 :         elements = (zend_llist_element **) emalloc(l->count * sizeof(zend_llist_element *));
     201             : 
     202           0 :         ptr = &elements[0];
     203             : 
     204           0 :         for (element=l->head; element; element=element->next) {
     205           0 :                 *ptr++ = element;
     206             :         }
     207             : 
     208           0 :         zend_qsort(elements, l->count, sizeof(zend_llist_element *), (compare_func_t) comp_func TSRMLS_CC);
     209             : 
     210           0 :         l->head = elements[0];
     211           0 :         elements[0]->prev = NULL;
     212             : 
     213           0 :         for (i = 1; i < l->count; i++) {
     214           0 :                 elements[i]->prev = elements[i-1];
     215           0 :                 elements[i-1]->next = elements[i];
     216             :         }
     217           0 :         elements[i-1]->next = NULL;
     218           0 :         l->tail = elements[i-1];
     219           0 :         efree(elements);
     220             : }
     221             : 
     222             : 
     223      190881 : ZEND_API void zend_llist_apply_with_argument(zend_llist *l, llist_apply_with_arg_func_t func, void *arg TSRMLS_DC)
     224             : {
     225             :         zend_llist_element *element;
     226             : 
     227      380553 :         for (element=l->head; element; element=element->next) {
     228      189672 :                 func(element->data, arg TSRMLS_CC);
     229             :         }
     230      190881 : }
     231             : 
     232             : 
     233       20180 : ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func TSRMLS_DC, int num_args, ...)
     234             : {
     235             :         zend_llist_element *element;
     236             :         va_list args;
     237             : 
     238       20180 :         va_start(args, num_args);
     239       20180 :         for (element=l->head; element; element=element->next) {
     240           0 :                 func(element->data, num_args, args TSRMLS_CC);
     241             :         }
     242       20180 :         va_end(args);
     243       20180 : }
     244             : 
     245             : 
     246         107 : ZEND_API int zend_llist_count(zend_llist *l)
     247             : {
     248         107 :         return l->count;
     249             : }
     250             : 
     251             : 
     252         719 : ZEND_API void *zend_llist_get_first_ex(zend_llist *l, zend_llist_position *pos)
     253             : {
     254         719 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     255             : 
     256         719 :         *current = l->head;
     257         719 :         if (*current) {
     258         705 :                 return (*current)->data;
     259             :         } else {
     260          14 :                 return NULL;
     261             :         }
     262             : }
     263             : 
     264             : 
     265       20127 : ZEND_API void *zend_llist_get_last_ex(zend_llist *l, zend_llist_position *pos)
     266             : {
     267       20127 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     268             : 
     269       20127 :         *current = l->tail;
     270       20127 :         if (*current) {
     271       20127 :                 return (*current)->data;
     272             :         } else {
     273           0 :                 return NULL;
     274             :         }
     275             : }
     276             : 
     277             : 
     278        1070 : ZEND_API void *zend_llist_get_next_ex(zend_llist *l, zend_llist_position *pos)
     279             : {
     280        1070 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     281             : 
     282        1070 :         if (*current) {
     283        1070 :                 *current = (*current)->next;
     284        1070 :                 if (*current) {
     285         494 :                         return (*current)->data;
     286             :                 }
     287             :         }
     288         576 :         return NULL;
     289             : }
     290             : 
     291             : 
     292           0 : ZEND_API void *zend_llist_get_prev_ex(zend_llist *l, zend_llist_position *pos)
     293             : {
     294           0 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     295             : 
     296           0 :         if (*current) {
     297           0 :                 *current = (*current)->prev;
     298           0 :                 if (*current) {
     299           0 :                         return (*current)->data;
     300             :                 }
     301             :         }
     302           0 :         return NULL;
     303             : }
     304             : 
     305             : /*
     306             :  * Local variables:
     307             :  * tab-width: 4
     308             :  * c-basic-offset: 4
     309             :  * indent-tabs-mode: t
     310             :  * End:
     311             :  */

Generated by: LCOV version 1.10

Generated at Fri, 19 Sep 2014 17:11:03 +0000 (20 hours ago)

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