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: 112 138 81.2 %
Date: 2014-07-21 Functions: 17 18 94.4 %
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     1280988 : ZEND_API void zend_llist_init(zend_llist *l, size_t size, llist_dtor_func_t dtor, unsigned char persistent)
      27             : {
      28     1280988 :         l->head  = NULL;
      29     1280988 :         l->tail  = NULL;
      30     1280988 :         l->count = 0;
      31     1280988 :         l->size  = size;
      32     1280988 :         l->dtor  = dtor;
      33     1280988 :         l->persistent = persistent;
      34     1280988 : }
      35             : 
      36             : 
      37      382499 : ZEND_API void zend_llist_add_element(zend_llist *l, void *element)
      38             : {
      39      382499 :         zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent);
      40             : 
      41      382499 :         tmp->prev = l->tail;
      42      382499 :         tmp->next = NULL;
      43      382499 :         if (l->tail) {
      44       30181 :                 l->tail->next = tmp;
      45             :         } else {
      46      352318 :                 l->head = tmp;
      47             :         }
      48      382499 :         l->tail = tmp;
      49      382499 :         memcpy(tmp->data, element, l->size);
      50             : 
      51      382499 :         ++l->count;
      52      382499 : }
      53             : 
      54             : 
      55         384 : ZEND_API void zend_llist_prepend_element(zend_llist *l, void *element)
      56             : {
      57         384 :         zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent);
      58             : 
      59         384 :         tmp->next = l->head;
      60         384 :         tmp->prev = NULL;
      61         384 :         if (l->head) {
      62         231 :                 l->head->prev = tmp;
      63             :         } else {
      64         153 :                 l->tail = tmp;
      65             :         }
      66         384 :         l->head = tmp;
      67         384 :         memcpy(tmp->data, element, l->size);
      68             : 
      69         384 :         ++l->count;
      70         384 : }
      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       51635 : ZEND_API void zend_llist_del_element(zend_llist *l, void *element, int (*compare)(void *element1, void *element2))
      92             : {
      93       51635 :         zend_llist_element *current=l->head;
      94             : 
      95      124008 :         while (current) {
      96       51608 :                 if (compare(current->data, element)) {
      97       30870 :                         DEL_LLIST_ELEMENT(current, l);
      98       30870 :                         break;
      99             :                 }
     100       20738 :                 current = current->next;
     101             :         }
     102       51635 : }
     103             : 
     104             : 
     105     1417824 : ZEND_API void zend_llist_destroy(zend_llist *l)
     106             : {
     107     1417824 :         zend_llist_element *current=l->head, *next;
     108             :         
     109     3187581 :         while (current) {
     110      351933 :                 next = current->next;
     111      351933 :                 if (l->dtor) {
     112       45690 :                         l->dtor(current->data);
     113             :                 }
     114      351933 :                 pefree(current, l->persistent);
     115      351933 :                 current = next;
     116             :         }
     117             : 
     118     1417824 :         l->count = 0;
     119     1417824 : }
     120             : 
     121             : 
     122      185674 : ZEND_API void zend_llist_clean(zend_llist *l)
     123             : {
     124      185674 :         zend_llist_destroy(l);
     125      185674 :         l->head = l->tail = NULL;
     126      185674 : }
     127             : 
     128             : 
     129         124 : ZEND_API void *zend_llist_remove_tail(zend_llist *l)
     130             : {
     131             :         zend_llist_element *old_tail;
     132             :         void *data;
     133             : 
     134         124 :         if ((old_tail = l->tail)) {
     135         124 :                 if (old_tail->prev) {
     136         124 :                         old_tail->prev->next = NULL;
     137             :                 } else {
     138           0 :                         l->head = NULL;
     139             :                 }
     140             :         
     141         124 :                 data = old_tail->data;
     142             : 
     143         124 :                 l->tail = old_tail->prev;
     144         124 :                 if (l->dtor) {
     145           0 :                         l->dtor(data);
     146             :                 }
     147         124 :                 pefree(old_tail, l->persistent);
     148             : 
     149         124 :                 --l->count;
     150             : 
     151         124 :                 return data;
     152             :         }
     153             : 
     154           0 :         return NULL;
     155             : }
     156             : 
     157             : 
     158         351 : ZEND_API void zend_llist_copy(zend_llist *dst, zend_llist *src)
     159             : {
     160             :         zend_llist_element *ptr;
     161             : 
     162         351 :         zend_llist_init(dst, src->size, src->dtor, src->persistent);
     163         351 :         ptr = src->head;
     164        1085 :         while (ptr) {
     165         383 :                 zend_llist_add_element(dst, ptr->data);
     166         383 :                 ptr = ptr->next;
     167             :         }
     168         351 : }
     169             : 
     170             : 
     171       21257 : ZEND_API void zend_llist_apply_with_del(zend_llist *l, int (*func)(void *data))
     172             : {
     173             :         zend_llist_element *element, *next;
     174             : 
     175       21257 :         element=l->head;
     176       63616 :         while (element) {
     177       21102 :                 next = element->next;
     178       21102 :                 if (func(element->data)) {
     179           0 :                         DEL_LLIST_ELEMENT(element, l);
     180             :                 }
     181       21102 :                 element = next;
     182             :         }
     183       21257 : }
     184             : 
     185             : 
     186      106292 : ZEND_API void zend_llist_apply(zend_llist *l, llist_apply_func_t func TSRMLS_DC)
     187             : {
     188             :         zend_llist_element *element;
     189             : 
     190      190791 :         for (element=l->head; element; element=element->next) {
     191       84499 :                 func(element->data TSRMLS_CC);
     192             :         }
     193      106292 : }
     194             : 
     195           1 : ZEND_API void zend_llist_sort(zend_llist *l, llist_compare_func_t comp_func TSRMLS_DC)
     196             : {
     197             :         size_t i;
     198             : 
     199             :         zend_llist_element **elements;
     200             :         zend_llist_element *element, **ptr;
     201             : 
     202           1 :         if (l->count <= 0) {
     203           1 :                 return;
     204             :         }
     205             : 
     206           0 :         elements = (zend_llist_element **) emalloc(l->count * sizeof(zend_llist_element *));
     207             : 
     208           0 :         ptr = &elements[0];
     209             : 
     210           0 :         for (element=l->head; element; element=element->next) {
     211           0 :                 *ptr++ = element;
     212             :         }
     213             : 
     214           0 :         zend_qsort(elements, l->count, sizeof(zend_llist_element *), (compare_func_t) comp_func TSRMLS_CC);
     215             : 
     216           0 :         l->head = elements[0];
     217           0 :         elements[0]->prev = NULL;
     218             : 
     219           0 :         for (i = 1; i < l->count; i++) {
     220           0 :                 elements[i]->prev = elements[i-1];
     221           0 :                 elements[i-1]->next = elements[i];
     222             :         }
     223           0 :         elements[i-1]->next = NULL;
     224           0 :         l->tail = elements[i-1];
     225           0 :         efree(elements);
     226             : }
     227             : 
     228             : 
     229      205641 : ZEND_API void zend_llist_apply_with_argument(zend_llist *l, llist_apply_with_arg_func_t func, void *arg TSRMLS_DC)
     230             : {
     231             :         zend_llist_element *element;
     232             : 
     233      410074 :         for (element=l->head; element; element=element->next) {
     234      204433 :                 func(element->data, arg TSRMLS_CC);
     235             :         }
     236      205641 : }
     237             : 
     238             : 
     239       21102 : ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func TSRMLS_DC, int num_args, ...)
     240             : {
     241             :         zend_llist_element *element;
     242             :         va_list args;
     243             : 
     244       21102 :         va_start(args, num_args);
     245       21102 :         for (element=l->head; element; element=element->next) {
     246           0 :                 func(element->data, num_args, args TSRMLS_CC);
     247             :         }
     248       21102 :         va_end(args);
     249       21102 : }
     250             : 
     251             : 
     252         109 : ZEND_API int zend_llist_count(zend_llist *l)
     253             : {
     254         109 :         return l->count;
     255             : }
     256             : 
     257             : 
     258         723 : ZEND_API void *zend_llist_get_first_ex(zend_llist *l, zend_llist_position *pos)
     259             : {
     260         723 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     261             : 
     262         723 :         *current = l->head;
     263         723 :         if (*current) {
     264         699 :                 return (*current)->data;
     265             :         } else {
     266          24 :                 return NULL;
     267             :         }
     268             : }
     269             : 
     270             : 
     271       21051 : ZEND_API void *zend_llist_get_last_ex(zend_llist *l, zend_llist_position *pos)
     272             : {
     273       21051 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     274             : 
     275       21051 :         *current = l->tail;
     276       21051 :         if (*current) {
     277       21051 :                 return (*current)->data;
     278             :         } else {
     279           0 :                 return NULL;
     280             :         }
     281             : }
     282             : 
     283             : 
     284        1052 : ZEND_API void *zend_llist_get_next_ex(zend_llist *l, zend_llist_position *pos)
     285             : {
     286        1052 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     287             : 
     288        1052 :         if (*current) {
     289        1052 :                 *current = (*current)->next;
     290        1052 :                 if (*current) {
     291         482 :                         return (*current)->data;
     292             :                 }
     293             :         }
     294         570 :         return NULL;
     295             : }
     296             : 
     297             : 
     298           0 : ZEND_API void *zend_llist_get_prev_ex(zend_llist *l, zend_llist_position *pos)
     299             : {
     300           0 :         zend_llist_position *current = pos ? pos : &l->traverse_ptr;
     301             : 
     302           0 :         if (*current) {
     303           0 :                 *current = (*current)->prev;
     304           0 :                 if (*current) {
     305           0 :                         return (*current)->data;
     306             :                 }
     307             :         }
     308           0 :         return NULL;
     309             : }
     310             : 
     311             : /*
     312             :  * Local variables:
     313             :  * tab-width: 4
     314             :  * c-basic-offset: 4
     315             :  * indent-tabs-mode: t
     316             :  * End:
     317             :  */

Generated by: LCOV version 1.10

Generated at Tue, 22 Jul 2014 01:33:05 +0000 (2 days ago)

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