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

LTP GCOV extension - code coverage report
Current view: directory - dbase - dbf_misc.c
Test: PHP Code Coverage
Date: 2009-11-19 Instrumented lines: 86
Code covered: 61.6 % Executed lines: 53
Legend: not executed executed

       1                 : /*
       2                 :  * Copyright (c) 1991, 1992, 1993 Brad Eacker,
       3                 :  *              (Music, Intuition, Software, and Computers)
       4                 :  * All Rights Reserved
       5                 :  */
       6                 : #include <stdlib.h>
       7                 : #include <stdio.h>
       8                 : #include <sys/types.h>
       9                 : 
      10                 : #include "dbf_misc.h"
      11                 : 
      12                 : #include "php_reentrancy.h"
      13                 : 
      14                 : /*
      15                 :  * routine to change little endian long to host long
      16                 :  */
      17                 : long get_long(char *cp)
      18               5 : {
      19                 :         int ret;
      20               5 :         unsigned char *source = (unsigned char *)cp;
      21                 : 
      22               5 :         ret = *source++;
      23               5 :         ret += ((*source++)<<8);
      24               5 :         ret += ((*source++)<<16);
      25               5 :         ret += ((*source++)<<24);
      26                 : 
      27               5 :         return ret;
      28                 : }
      29                 : 
      30                 : void put_long(char *cp, long lval)
      31              19 : {
      32              19 :         *cp++ = lval & 0xff;
      33              19 :         *cp++ = (lval >> 8) & 0xff;
      34              19 :         *cp++ = (lval >> 16) & 0xff;
      35              19 :         *cp++ = (lval >> 24) & 0xff;
      36              19 : }
      37                 : 
      38                 : /*
      39                 :  * routine to change little endian short to host short
      40                 :  */
      41                 : int get_short(char *cp)
      42              20 : {
      43                 :         int ret;
      44              20 :         unsigned char *source = (unsigned char *)cp;
      45                 : 
      46              20 :         ret = *source++;
      47              20 :         ret += ((*source++)<<8);
      48                 : 
      49              20 :         return ret;
      50                 : }
      51                 : 
      52                 : void put_short(char *cp, int sval)
      53             104 : {
      54             104 :         *cp++ = sval & 0xff;
      55             104 :         *cp++ = (sval >> 8) & 0xff;
      56             104 : }
      57                 : 
      58                 : double get_double(char *cp)
      59               0 : {
      60                 :         double ret;
      61               0 :         unsigned char *dp = (unsigned char *)&ret;
      62                 : 
      63               0 :         dp[7] = *cp++;
      64               0 :         dp[6] = *cp++;
      65               0 :         dp[5] = *cp++;
      66               0 :         dp[4] = *cp++;
      67               0 :         dp[3] = *cp++;
      68               0 :         dp[2] = *cp++;
      69               0 :         dp[1] = *cp++;
      70               0 :         dp[0] = *cp++;
      71                 : 
      72               0 :         return ret;
      73                 : }
      74                 : 
      75                 : void put_double(char *cp, double fval)
      76               0 : {
      77               0 :         unsigned char *dp = (unsigned char *)&fval;
      78                 : 
      79               0 :         cp[7] = *dp++;
      80               0 :         cp[6] = *dp++;
      81               0 :         cp[5] = *dp++;
      82               0 :         cp[4] = *dp++;
      83               0 :         cp[3] = *dp++;
      84               0 :         cp[2] = *dp++;
      85               0 :         cp[1] = *dp++;
      86               0 :         cp[0] = *dp++;
      87               0 : }
      88                 : 
      89                 : void copy_fill(char *dp, char *sp, int len)
      90               0 : {
      91               0 :         while (*sp && len > 0) {
      92               0 :                 *dp++ = *sp++;
      93               0 :                 len--;
      94                 :         }
      95               0 :         while (len-- > 0)
      96               0 :                 *dp++ = ' ';
      97               0 : }
      98                 : 
      99                 : void copy_crimp(char *dp, char *sp, int len)
     100              47 : {
     101             452 :         while (len-- > 0) {
     102             358 :                 *dp++ = *sp++;
     103                 :         }
     104              47 :         *dp = 0;
     105              47 :         for (dp-- ; *dp == ' '; dp--) {
     106               0 :                 *dp = 0;
     107                 :         }
     108                 : 
     109              47 : }
     110                 : 
     111                 : void db_set_date(char *cp, int year, int month, int day)
     112              24 : {
     113              24 :         if (month > 12)
     114               0 :                 month = 0;
     115              24 :         if (day > 31)
     116               0 :                 day = 0;
     117              24 :         snprintf(cp, 9, "%04d%02d%02d", year, month, day);
     118              24 : }
     119                 : 
     120                 : int db_date_year(char *cp)
     121              19 : {
     122                 :         int     year, i;
     123                 : 
     124              95 :         for (year = 0, i = 0; i < 4; i++)
     125              76 :                 year = year * 10 + (cp[i] - '0');
     126              19 :         return year;
     127                 : }
     128                 : 
     129                 : int db_date_month(char *cp)
     130              19 : {
     131                 :         int     month, i;
     132                 : 
     133              57 :         for (month = 0, i = 4; i < 6; i++)
     134              38 :                 month = month * 10 + (cp[i] - '0');
     135              19 :         return month;
     136                 : }
     137                 : 
     138                 : int db_date_day(char *cp)
     139              19 : {
     140                 :         int     day, i;
     141                 : 
     142              57 :         for (day = 0, i = 6; i < 8; i++)
     143              38 :                 day = day * 10 + (cp[i] - '0');
     144              19 :         return day;
     145                 : }
     146                 : 
     147                 : #include <time.h>
     148                 : 
     149                 : char *db_cur_date(char *cp)
     150              19 : {
     151                 :         struct tm *ctm, tmbuf;
     152                 :         time_t    c_time;
     153                 : 
     154              19 :         c_time = time((time_t *)NULL);
     155              19 :         ctm = php_localtime_r(&c_time, &tmbuf);
     156              19 :         if (cp == NULL)
     157              19 :                 cp = (char *)malloc(9);
     158                 : 
     159              19 :         if (ctm == NULL || cp == NULL)
     160               0 :                 return NULL;
     161                 : 
     162              19 :         db_set_date(cp, ctm->tm_year + 1900, ctm->tm_mon + 1, ctm->tm_mday);
     163                 : 
     164              19 :         return cp;
     165                 : }
     166                 : 
     167                 : /*
     168                 :  * Local variables:
     169                 :  * tab-width: 4
     170                 :  * c-basic-offset: 4
     171                 :  * End:
     172                 :  * vim600: sw=4 ts=4 fdm=marker
     173                 :  * vim<600: sw=4 ts=4
     174                 :  */

Generated by: LTP GCOV extension version 1.5

Generated at Thu, 19 Nov 2009 08:20:06 +0000 (5 days ago)

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