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 - ext/dba/libflatfile - flatfile.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 124 158 78.5 %
Date: 2014-09-29 Functions: 7 7 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP 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.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Marcus Boerger <helly@php.net>                              |
      16             :    | based on ext/db/db.c by:                                             |
      17             :    |          Rasmus Lerdorf <rasmus@php.net>                             |
      18             :    |          Jim Winstead <jimw@php.net>                                 |
      19             :    +----------------------------------------------------------------------+
      20             :  */
      21             : 
      22             : /* $Id: a1fce218ab7b7d67f4d8eb1c8f931246e35e5247 $ */
      23             : 
      24             : #ifdef HAVE_CONFIG_H
      25             : #include "config.h"
      26             : #endif
      27             : 
      28             : #include "php.h"
      29             : #include "php_globals.h"
      30             : 
      31             : #include <stdlib.h>
      32             : #include <string.h>
      33             : #include <errno.h>
      34             : #if HAVE_UNISTD_H
      35             : #include <unistd.h>
      36             : #endif
      37             : 
      38             : #include "flatfile.h"
      39             : 
      40             : #define FLATFILE_BLOCK_SIZE 1024
      41             : 
      42             : /*
      43             :  * ret = -1 means that database was opened for read-only
      44             :  * ret = 0  success
      45             :  * ret = 1  key already exists - nothing done
      46             :  */
      47             : 
      48             : /* {{{ flatfile_store
      49             :  */
      50          66 : int flatfile_store(flatfile *dba, datum key_datum, datum value_datum, int mode TSRMLS_DC) {
      51          66 :         if (mode == FLATFILE_INSERT) {
      52          57 :                 if (flatfile_findkey(dba, key_datum TSRMLS_CC)) {
      53           4 :                         return 1;
      54             :                 }
      55          53 :                 php_stream_seek(dba->fp, 0L, SEEK_END);
      56          53 :                 php_stream_printf(dba->fp TSRMLS_CC, "%zu\n", key_datum.dsize);
      57          53 :                 php_stream_flush(dba->fp);
      58          53 :                 if (php_stream_write(dba->fp, key_datum.dptr, key_datum.dsize) < key_datum.dsize) {
      59           0 :                         return -1;
      60             :                 }
      61          53 :                 php_stream_printf(dba->fp TSRMLS_CC, "%zu\n", value_datum.dsize);
      62          53 :                 php_stream_flush(dba->fp);
      63          53 :                 if (php_stream_write(dba->fp, value_datum.dptr, value_datum.dsize) < value_datum.dsize) {
      64           0 :                         return -1;
      65             :                 }
      66             :         } else { /* FLATFILE_REPLACE */
      67           9 :                 flatfile_delete(dba, key_datum TSRMLS_CC);
      68           9 :                 php_stream_printf(dba->fp TSRMLS_CC, "%zu\n", key_datum.dsize);
      69           9 :                 php_stream_flush(dba->fp);
      70           9 :                 if (php_stream_write(dba->fp, key_datum.dptr, key_datum.dsize) < key_datum.dsize) {
      71           0 :                         return -1;
      72             :                 }
      73           9 :                 php_stream_printf(dba->fp TSRMLS_CC, "%zu\n", value_datum.dsize);
      74           9 :                 if (php_stream_write(dba->fp, value_datum.dptr, value_datum.dsize) < value_datum.dsize) {
      75           0 :                         return -1;
      76             :                 }
      77             :         }
      78             : 
      79          62 :         php_stream_flush(dba->fp);
      80          62 :         return 0;
      81             : }
      82             : /* }}} */
      83             : 
      84             : /* {{{ flatfile_fetch
      85             :  */
      86          75 : datum flatfile_fetch(flatfile *dba, datum key_datum TSRMLS_DC) {
      87          75 :         datum value_datum = {NULL, 0};
      88             :         char buf[16];
      89             : 
      90          75 :         if (flatfile_findkey(dba, key_datum TSRMLS_CC)) {
      91          64 :                 if (php_stream_gets(dba->fp, buf, sizeof(buf))) {
      92          64 :                         value_datum.dsize = atoi(buf);
      93          64 :                         value_datum.dptr = safe_emalloc(value_datum.dsize, 1, 1);
      94          64 :                         value_datum.dsize = php_stream_read(dba->fp, value_datum.dptr, value_datum.dsize);
      95             :                 } else {
      96           0 :                         value_datum.dptr = NULL;
      97           0 :                         value_datum.dsize = 0;
      98             :                 }
      99             :         }
     100          75 :         return value_datum;
     101             : }
     102             : /* }}} */
     103             : 
     104             : /* {{{ flatfile_delete
     105             :  */
     106          23 : int flatfile_delete(flatfile *dba, datum key_datum TSRMLS_DC) {
     107          23 :         char *key = key_datum.dptr;
     108          23 :         size_t size = key_datum.dsize;
     109          23 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     110          23 :         char *buf = emalloc(buf_size);
     111             :         size_t num;
     112             :         size_t pos;
     113             : 
     114          23 :         php_stream_rewind(dba->fp);
     115          92 :         while(!php_stream_eof(dba->fp)) {
     116             :                 /* read in the length of the key name */
     117          69 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     118           0 :                         break;
     119             :                 }
     120          69 :                 num = atoi(buf);
     121          69 :                 if (num >= buf_size) {
     122           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     123           0 :                         buf = erealloc(buf, buf_size);
     124             :                 }
     125          69 :                 pos = php_stream_tell(dba->fp);
     126             : 
     127             :                 /* read in the key name */
     128          69 :                 num = php_stream_read(dba->fp, buf, num);
     129          69 :                 if (num < 0)  {
     130             :                         break;
     131             :                 }
     132             : 
     133          69 :                 if (size == num && !memcmp(buf, key, size)) {
     134          23 :                         php_stream_seek(dba->fp, pos, SEEK_SET);
     135          23 :                         php_stream_putc(dba->fp, 0);
     136          23 :                         php_stream_flush(dba->fp);
     137          23 :                         php_stream_seek(dba->fp, 0L, SEEK_END);
     138          23 :                         efree(buf);
     139          23 :                         return SUCCESS;
     140             :                 }       
     141             : 
     142             :                 /* read in the length of the value */
     143          46 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     144           0 :                         break;
     145             :                 }
     146          46 :                 num = atoi(buf);
     147          46 :                 if (num >= buf_size) {
     148           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     149           0 :                         buf = erealloc(buf, buf_size);
     150             :                 }
     151             :                 /* read in the value */
     152          46 :                 num = php_stream_read(dba->fp, buf, num);
     153          46 :                 if (num < 0) {
     154             :                         break;
     155             :                 }
     156             :         }
     157           0 :         efree(buf);
     158           0 :         return FAILURE;
     159             : }       
     160             : /* }}} */
     161             : 
     162             : /* {{{ flatfile_findkey
     163             :  */
     164         132 : int flatfile_findkey(flatfile *dba, datum key_datum TSRMLS_DC) {
     165         132 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     166         132 :         char *buf = emalloc(buf_size);
     167             :         size_t num;
     168         132 :         int ret=0;
     169         132 :         void *key = key_datum.dptr;
     170         132 :         size_t size = key_datum.dsize;
     171             : 
     172         132 :         php_stream_rewind(dba->fp);
     173         665 :         while (!php_stream_eof(dba->fp)) {
     174         533 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     175          64 :                         break;
     176             :                 }
     177         469 :                 num = atoi(buf);
     178         469 :                 if (num >= buf_size) {
     179           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     180           0 :                         buf = erealloc(buf, buf_size);
     181             :                 }
     182         469 :                 num = php_stream_read(dba->fp, buf, num);
     183         469 :                 if (num < 0) {
     184             :                         break;
     185             :                 }
     186         469 :                 if (size == num) {
     187         355 :                         if (!memcmp(buf, key, size)) {
     188          68 :                                 ret = 1;
     189          68 :                                 break;
     190             :                         }
     191             :                 }       
     192         401 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     193           0 :                         break;
     194             :                 }
     195         401 :                 num = atoi(buf);
     196         401 :                 if (num >= buf_size) {
     197           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     198           0 :                         buf = erealloc(buf, buf_size);
     199             :                 }
     200         401 :                 num = php_stream_read(dba->fp, buf, num);
     201         401 :                 if (num < 0) {
     202             :                         break;
     203             :                 }
     204             :         }
     205         132 :         efree(buf);
     206         132 :         return ret;
     207             : }
     208             : /* }}} */
     209             : 
     210             : /* {{{ flatfile_firstkey
     211             :  */
     212          13 : datum flatfile_firstkey(flatfile *dba TSRMLS_DC) {
     213             :         datum res;
     214             :         size_t num;
     215          13 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     216          13 :         char *buf = emalloc(buf_size);
     217             : 
     218          13 :         php_stream_rewind(dba->fp);
     219          47 :         while(!php_stream_eof(dba->fp)) {
     220          34 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     221           0 :                         break;
     222             :                 }
     223          34 :                 num = atoi(buf);
     224          34 :                 if (num >= buf_size) {
     225           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     226           0 :                         buf = erealloc(buf, buf_size);
     227             :                 }
     228          34 :                 num = php_stream_read(dba->fp, buf, num);
     229          34 :                 if (num < 0) {
     230             :                         break;
     231             :                 }
     232          34 :                 if (*(buf) != 0) {
     233          13 :                         dba->CurrentFlatFilePos = php_stream_tell(dba->fp);
     234          13 :                         res.dptr = buf;
     235          13 :                         res.dsize = num;
     236          13 :                         return res;
     237             :                 }
     238          21 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     239           0 :                         break;
     240             :                 }
     241          21 :                 num = atoi(buf);
     242          21 :                 if (num >= buf_size) {
     243           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     244           0 :                         buf = erealloc(buf, buf_size);
     245             :                 }
     246          21 :                 num = php_stream_read(dba->fp, buf, num);
     247          21 :                 if (num < 0) {
     248             :                         break;
     249             :                 }
     250             :         }
     251           0 :         efree(buf);
     252           0 :         res.dptr = NULL;
     253           0 :         res.dsize = 0;
     254           0 :         return res;
     255             : }
     256             : /* }}} */
     257             : 
     258             : /* {{{ flatfile_nextkey
     259             :  */
     260          42 : datum flatfile_nextkey(flatfile *dba TSRMLS_DC) {
     261             :         datum res;
     262             :         size_t num;
     263          42 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     264          42 :         char *buf = emalloc(buf_size);
     265             : 
     266          42 :         php_stream_seek(dba->fp, dba->CurrentFlatFilePos, SEEK_SET);
     267          42 :         while(!php_stream_eof(dba->fp)) {
     268          51 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     269           0 :                         break;
     270             :                 }
     271          51 :                 num = atoi(buf);
     272          51 :                 if (num >= buf_size) {
     273           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     274           0 :                         buf = erealloc(buf, buf_size);
     275             :                 }
     276          51 :                 num = php_stream_read(dba->fp, buf, num);
     277          51 :                 if (num < 0)  {
     278             :                         break;
     279             :                 }
     280          51 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     281          13 :                         break;
     282             :                 }
     283          38 :                 num = atoi(buf);
     284          38 :                 if (num >= buf_size) {
     285           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     286           0 :                         buf = erealloc(buf, buf_size);
     287             :                 }
     288          38 :                 num = php_stream_read(dba->fp, buf, num);
     289          38 :                 if (num < 0) {
     290             :                         break;
     291             :                 }
     292          38 :                 if (*(buf)!=0) {
     293          29 :                         dba->CurrentFlatFilePos = php_stream_tell(dba->fp);
     294          29 :                         res.dptr = buf;
     295          29 :                         res.dsize = num;
     296          29 :                         return res;
     297             :                 }
     298             :         }
     299          13 :         efree(buf);
     300          13 :         res.dptr = NULL;
     301          13 :         res.dsize = 0;
     302          13 :         return res;
     303             : }       
     304             : /* }}} */
     305             : 
     306             : /* {{{ flatfile_version */
     307           2 : char *flatfile_version() 
     308             : {
     309           2 :         return "1.0, $Id: a1fce218ab7b7d67f4d8eb1c8f931246e35e5247 $";
     310             : }
     311             : /* }}} */ 
     312             : 
     313             : /*
     314             :  * Local variables:
     315             :  * tab-width: 4
     316             :  * c-basic-offset: 4
     317             :  * End:
     318             :  * vim600: sw=4 ts=4 fdm=marker
     319             :  * vim<600: sw=4 ts=4
     320             :  */

Generated by: LCOV version 1.10

Generated at Mon, 29 Sep 2014 14:26:20 +0000 (43 hours ago)

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