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/standard - strnatcmp.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 72 74 97.3 %
Date: 2014-10-30 Functions: 3 3 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- mode: c; c-file-style: "k&r" -*-
       2             : 
       3             :   Modified for PHP by Andrei Zmievski <andrei@ispi.net>
       4             : 
       5             :   strnatcmp.c -- Perform 'natural order' comparisons of strings in C.
       6             :   Copyright (C) 2000 by Martin Pool <mbp@humbug.org.au>
       7             : 
       8             :   This software is provided 'as-is', without any express or implied
       9             :   warranty.  In no event will the authors be held liable for any damages
      10             :   arising from the use of this software.
      11             : 
      12             :   Permission is granted to anyone to use this software for any purpose,
      13             :   including commercial applications, and to alter it and redistribute it
      14             :   freely, subject to the following restrictions:
      15             : 
      16             :   1. The origin of this software must not be misrepresented; you must not
      17             :      claim that you wrote the original software. If you use this software
      18             :      in a product, an acknowledgment in the product documentation would be
      19             :      appreciated but is not required.
      20             :   2. Altered source versions must be plainly marked as such, and must not be
      21             :      misrepresented as being the original software.
      22             :   3. This notice may not be removed or altered from any source distribution.
      23             : */
      24             : 
      25             : #include <ctype.h>
      26             : #include <string.h>
      27             : #include <assert.h>
      28             : #include <stdio.h>
      29             : 
      30             : #include "php.h"
      31             : #include "php_string.h"
      32             : 
      33             : #if defined(__GNUC__)
      34             : #  define UNUSED __attribute__((__unused__))
      35             : #else
      36             : #  define UNUSED
      37             : #endif
      38             : 
      39             : #if 0
      40             : static char const *version UNUSED =
      41             :     "$Id$";
      42             : #endif
      43             : /* {{{ compare_right
      44             :  */
      45             : static int
      46         239 : compare_right(char const **a, char const *aend, char const **b, char const *bend)
      47             : {
      48         239 :         int bias = 0;
      49             : 
      50             :         /* The longest run of digits wins.  That aside, the greatest
      51             :            value wins, but we can't know that it will until we've scanned
      52             :            both numbers to know that they have the same magnitude, so we
      53             :            remember it in BIAS. */
      54         326 :         for(;; (*a)++, (*b)++) {
      55         819 :                 if ((*a == aend || !isdigit((int)(unsigned char)**a)) &&
      56         254 :                         (*b == bend || !isdigit((int)(unsigned char)**b)))
      57         128 :                         return bias;
      58         437 :                 else if (*a == aend || !isdigit((int)(unsigned char)**a))
      59          47 :                         return -1;
      60         390 :                 else if (*b == bend || !isdigit((int)(unsigned char)**b))
      61          64 :                         return +1;
      62         326 :                 else if (**a < **b) {
      63         104 :                         if (!bias)
      64          75 :                                 bias = -1;
      65         222 :                 } else if (**a > **b) {
      66         134 :                         if (!bias)
      67         106 :                                 bias = +1;
      68             :                 }
      69         326 :      }
      70             : 
      71             :      return 0;
      72             : }
      73             : /* }}} */
      74             : 
      75             : /* {{{ compare_left
      76             :  */
      77             : static int
      78          44 : compare_left(char const **a, char const *aend, char const **b, char const *bend)
      79             : {
      80             :      /* Compare two left-aligned numbers: the first to have a
      81             :         different value wins. */
      82          10 :         for(;; (*a)++, (*b)++) {
      83          55 :                 if ((*a == aend || !isdigit((int)(unsigned char)**a)) &&
      84          11 :                         (*b == bend || !isdigit((int)(unsigned char)**b)))
      85           8 :                         return 0;
      86          36 :                 else if (*a == aend || !isdigit((int)(unsigned char)**a))
      87           0 :                         return -1;
      88          36 :                 else if (*b == bend || !isdigit((int)(unsigned char)**b))
      89           0 :                         return +1;
      90          36 :                  else if (**a < **b)
      91          17 :                          return -1;
      92          19 :                  else if (**a > **b)
      93           9 :                          return +1;
      94          10 :      }
      95             :           
      96             :      return 0;
      97             : }
      98             : /* }}} */
      99             : 
     100             : /* {{{ strnatcmp_ex
     101             :  */
     102         665 : PHPAPI int strnatcmp_ex(char const *a, size_t a_len, char const *b, size_t b_len, int fold_case)
     103             : {
     104             :         unsigned char ca, cb;
     105             :         char const *ap, *bp;
     106         665 :         char const *aend = a + a_len,
     107         665 :                            *bend = b + b_len;
     108             :         int fractional, result;
     109         665 :         short leading = 1;
     110             : 
     111         665 :         if (a_len == 0 || b_len == 0) {
     112          22 :                 return (a_len == b_len ? 0 : (a_len > b_len ? 1 : -1));
     113             :         }
     114             : 
     115         643 :         ap = a;
     116         643 :         bp = b;
     117             :         while (1) {
     118        1382 :                 ca = *ap; cb = *bp;
     119             : 
     120             :                 /* skip over leading zeros */
     121        2832 :                 while (leading && ca == '0' && (ap+1 < aend) && isdigit(*(ap+1))) {
     122          68 :                         ca = *++ap;
     123             :                 }
     124             : 
     125        2809 :                 while (leading && cb == '0' && (bp+1 < bend) && isdigit(*(bp+1))) {
     126          45 :                         cb = *++bp;
     127             :                 }
     128             : 
     129        1382 :                 leading = 0;
     130             : 
     131             :                 /* Skip consecutive whitespace */
     132        2780 :                 while (isspace((int)(unsigned char)ca)) {
     133          16 :                         ca = *++ap;
     134             :                 }
     135             : 
     136        2781 :                 while (isspace((int)(unsigned char)cb)) {
     137          17 :                         cb = *++bp;
     138             :                 }
     139             : 
     140             :                 /* process run of digits */
     141        1382 :                 if (isdigit((int)(unsigned char)ca)  &&  isdigit((int)(unsigned char)cb)) {
     142         273 :                         fractional = (ca == '0' || cb == '0');
     143             : 
     144         273 :                         if (fractional)
     145          34 :                                 result = compare_left(&ap, aend, &bp, bend);
     146             :                         else
     147         239 :                                 result = compare_right(&ap, aend, &bp, bend);
     148             : 
     149         273 :                         if (result != 0)
     150         248 :                                 return result;
     151          25 :                         else if (ap == aend && bp == bend)
     152             :                                 /* End of the strings. Let caller sort them out. */
     153          10 :                                 return 0;
     154             :                         else {
     155             :                                 /* Keep on comparing from the current point. */
     156          15 :                                 ca = *ap; cb = *bp;
     157             :                         }
     158             :                 }
     159             : 
     160        1124 :                 if (fold_case) {
     161         783 :                         ca = toupper((int)(unsigned char)ca);
     162         783 :                         cb = toupper((int)(unsigned char)cb);
     163             :                 }
     164             : 
     165        1124 :                 if (ca < cb)
     166         141 :                         return -1;
     167         983 :                 else if (ca > cb)
     168         181 :                         return +1;
     169             : 
     170         802 :                 ++ap; ++bp;
     171         802 :                 if (ap >= aend && bp >= bend)
     172             :                         /* The strings compare the same.  Perhaps the caller
     173             :                            will want to call strcmp to break the tie. */
     174          31 :                         return 0;
     175         771 :                 else if (ap >= aend)
     176          11 :                         return -1;
     177         760 :                 else if (bp >= bend)
     178          21 :                         return 1;
     179         739 :         }
     180             : }
     181             : /* }}} */
     182             : 
     183             : /*
     184             :  * Local variables:
     185             :  * tab-width: 4
     186             :  * c-basic-offset: 4
     187             :  * End:
     188             :  * vim600: sw=4 ts=4 fdm=marker
     189             :  * vim<600: sw=4 ts=4
     190             :  */

Generated by: LCOV version 1.10

Generated at Thu, 30 Oct 2014 07:41:40 +0000 (9 hours ago)

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