LTP GCOV extension - code coverage report
Current view: directory - src/utils/text - min_text.c
Test: min.info
Date: 2009-06-18 Instrumented lines: 169
Code covered: 87.6 % Executed lines: 148

       1                 : /*
       2                 :  * This file is part of MIN Test Framework. Copyright © 2008 Nokia Corporation
       3                 :  * and/or its subsidiary(-ies).
       4                 :  * Contact: Konrad Marek Zapalowicz
       5                 :  * Contact e-mail: DG.MIN-Support@nokia.com
       6                 :  * 
       7                 :  * This program is free software: you can redistribute it and/or modify it 
       8                 :  * under the terms of the GNU General Public License as published by the Free 
       9                 :  * Software Foundation, version 2 of the License. 
      10                 :  * 
      11                 :  * This program is distributed in the hope that it will be useful, but WITHOUT 
      12                 :  * ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or 
      13                 :  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General  Public License for
      14                 :  * more details. You should have received a copy of the GNU General Public 
      15                 :  * License along with this program. If not,  see 
      16                 :  * <http://www.gnu.org/licenses/>.
      17                 :  */
      18                 : 
      19                 : 
      20                 : /**
      21                 :  *  @file       text.c
      22                 :  *  @version    0.1
      23                 :  *  @brief      This file contains implementation of Text interface.
      24                 :  */
      25                 : 
      26                 : /* ------------------------------------------------------------------------- */
      27                 : /* INCLUDE FILES */
      28                 : #include <stdio.h>
      29                 : #include <min_text.h>
      30                 : 
      31                 : /* ------------------------------------------------------------------------- */
      32                 : /* EXTERNAL DATA STRUCTURES */
      33                 : /* None */
      34                 : 
      35                 : /* ------------------------------------------------------------------------- */
      36                 : /* EXTERNAL GLOBAL VARIABLES */
      37                 : /* None */
      38                 : 
      39                 : /* ------------------------------------------------------------------------- */
      40                 : /* EXTERNAL FUNCTION PROTOTYPES */
      41                 : /* None */
      42                 : 
      43                 : /* ------------------------------------------------------------------------- */
      44                 : /* GLOBAL VARIABLES */
      45                 : /* None */
      46                 : 
      47                 : /* ------------------------------------------------------------------------- */
      48                 : /* CONSTANTS */
      49                 : /* None */
      50                 : 
      51                 : /* ------------------------------------------------------------------------- */
      52                 : /* MACROS */
      53                 : 
      54                 : /* ------------------------------------------------------------------------- */
      55                 : /* LOCAL GLOBAL VARIABLES */
      56                 : /* None */
      57                 : 
      58                 : /* ------------------------------------------------------------------------- */
      59                 : /* LOCAL CONSTANTS AND MACROS */
      60                 : /* None */
      61                 : 
      62                 : /* ------------------------------------------------------------------------- */
      63                 : /* MODULE DATA STRUCTURES */
      64                 : /* None */
      65                 : 
      66                 : /* ------------------------------------------------------------------------- */
      67                 : /* LOCAL FUNCTION PROTOTYPES */
      68                 : /* None */
      69                 : 
      70                 : /* ------------------------------------------------------------------------- */
      71                 : /* FORWARD DECLARATIONS */
      72                 : /* None */
      73                 : 
      74                 : /* ------------------------------------------------------------------------- */
      75                 : /* ==================== LOCAL FUNCTIONS ==================================== */
      76                 : /* None */
      77                 : 
      78                 : /* ------------------------------------------------------------------------- */
      79                 : /* ======================== FUNCTIONS ====================================== */
      80                 : /* ------------------------------------------------------------------------- */
      81                 : Text           *tx_create (const char *txt)
      82          141865 : {
      83          141865 :         Text           *retval = NEW (Text);
      84          141865 :         unsigned int    tlen = 0;
      85          141865 :         unsigned int    tmp = 0;
      86                 : 
      87          141865 :         retval->max_size_ = MaxTextBufferSize;
      88          141865 :         retval->buf_ = NEW2 (char, MaxTextBufferSize);
      89          141865 :         memset (retval->buf_, '\0', MaxTextBufferSize);
      90          141865 :         retval->size_ = 0;
      91                 : 
      92          141865 :         if (txt == INITPTR || txt == NULL) {
      93                 :                 goto EXIT;
      94                 :         }
      95                 : 
      96          141759 :         tlen = strlen (txt);
      97                 : 
      98          141759 :         if (tlen == 0) {
      99          125747 :                 goto EXIT;
     100                 :         }
     101                 : 
     102           16012 :         tmp = ((int)((float)tlen / (float)MaxTextBufferSize)) + 1;
     103                 : 
     104           16012 :         if (tmp > 1) {
     105               3 :                 DELETE (retval->buf_);
     106               3 :                 retval->max_size_ = tmp * MaxTextBufferSize;
     107               3 :                 retval->buf_ = NEW2 (char, retval->max_size_);
     108               3 :                 memset (retval->buf_, '\0', retval->max_size_);
     109                 :         }
     110                 : 
     111           16012 :         STRCPY (retval->buf_, txt, tlen);
     112           16012 :         retval->size_ = tlen;
     113          141865 :       EXIT:
     114          141865 :         return retval;
     115                 : }
     116                 : 
     117                 : /* ------------------------------------------------------------------------- */
     118                 : void tx_destroy (Text ** txt)
     119          141626 : {
     120          141626 :         if (txt != INITPTR) {
     121          141625 :                 if (*txt != INITPTR) {
     122          141549 :                         DELETE ((*txt)->buf_)
     123          141549 :                             DELETE (*txt);
     124          141549 :                         *txt = INITPTR;
     125                 :                 }
     126                 :         }
     127          141626 : }
     128                 : 
     129                 : /* ------------------------------------------------------------------------- */
     130                 : void tx_append (Text * dest, const Text * src)
     131             118 : {
     132             118 :         unsigned int    space = 0;
     133             118 :         unsigned int    totalsize = 0;
     134             118 :         unsigned int    tmp = 0;
     135             118 :         char           *tmpbuf = INITPTR;
     136                 : 
     137             118 :         if (dest == INITPTR) {
     138               2 :                 goto EXIT;
     139                 :         }
     140             116 :         if (src == INITPTR) {
     141               1 :                 goto EXIT;
     142                 :         }
     143                 : 
     144             115 :         space = dest->max_size_ - dest->size_;
     145                 : 
     146             115 :         if (src->size_ > space) {
     147               3 :                 totalsize = dest->size_ + src->size_;
     148               3 :                 tmp =
     149                 :                     ((int)((float)totalsize / (float)MaxTextBufferSize)) + 1;
     150               3 :                 dest->max_size_ = tmp * MaxTextBufferSize;
     151               3 :                 tmpbuf = NEW2 (char, dest->max_size_);
     152               3 :                 memset (tmpbuf, '\0', dest->max_size_);
     153               3 :                 STRCPY (tmpbuf, dest->buf_, dest->size_);
     154               3 :                 STRCPY (&tmpbuf[dest->size_], src->buf_, src->size_);
     155               3 :                 dest->size_ = totalsize;
     156               3 :                 DELETE (dest->buf_);
     157               3 :                 dest->buf_ = tmpbuf;
     158                 :         } else {
     159             112 :                 STRCPY (&dest->buf_[dest->size_], src->buf_, src->size_);
     160             112 :                 dest->size_ += src->size_;
     161                 :         }
     162                 : 
     163             118 :       EXIT:
     164                 :         return;
     165                 : }
     166                 : 
     167                 : /* ------------------------------------------------------------------------- */
     168                 : void tx_copy (Text * dest, const Text * src)
     169             118 : {
     170             118 :         if (dest == INITPTR) {
     171               2 :                 goto EXIT;
     172                 :         }
     173             116 :         if (src == INITPTR) {
     174               1 :                 goto EXIT;
     175                 :         }
     176             115 :         if (dest == src) {
     177               1 :                 goto EXIT;
     178                 :         }
     179                 : 
     180             114 :         DELETE (dest->buf_);
     181                 : 
     182             114 :         dest->max_size_ = src->max_size_;
     183             114 :         dest->buf_ = NEW2 (char, dest->max_size_);
     184             114 :         memset (dest->buf_, '\0', dest->max_size_);
     185             114 :         dest->size_ = src->size_;
     186                 : 
     187             114 :         STRCPY (dest->buf_, src->buf_, dest->size_);
     188             118 :       EXIT:
     189                 :         return;
     190                 : }
     191                 : 
     192                 : /* ------------------------------------------------------------------------- */
     193                 : void tx_c_append (Text * dest, const char *src)
     194         1807686 : {
     195         1807686 :         unsigned int    space = 0;
     196         1807686 :         unsigned int    totalsize = 0;
     197         1807686 :         unsigned int    tmpsize = 0;
     198         1807686 :         unsigned int    slen = 0;
     199         1807686 :         char           *tmpbuf = INITPTR;
     200                 : 
     201         1807686 :         if (dest == INITPTR) {
     202               2 :                 goto EXIT;
     203                 :         }
     204         1807684 :         if (src == INITPTR) {
     205               1 :                 goto EXIT;
     206                 :         }
     207                 : 
     208         1807683 :         space = dest->max_size_ - dest->size_;
     209         1807683 :         slen = strlen (src);
     210                 : 
     211         1807683 :         if (slen >= space) {
     212             125 :                 totalsize = dest->size_ + slen;
     213             125 :                 tmpsize =
     214                 :                     ((int)((float)totalsize / (float)MaxTextBufferSize)) + 1;
     215             125 :                 dest->max_size_ = tmpsize * MaxTextBufferSize;
     216             125 :                 tmpbuf = NEW2 (char, dest->max_size_);
     217             125 :                 memset (tmpbuf, '\0', dest->max_size_);
     218             125 :                 STRCPY (tmpbuf, dest->buf_, dest->size_);
     219             125 :                 STRCPY (&tmpbuf[dest->size_], src, slen);
     220             125 :                 dest->size_ = totalsize;
     221             125 :                 DELETE (dest->buf_);
     222             125 :                 dest->buf_ = tmpbuf;
     223                 :         } else {
     224         1807558 :                 STRCPY (&dest->buf_[dest->size_], src, slen);
     225         1807558 :                 dest->size_ += slen;
     226                 :         }
     227                 : 
     228         1807686 :       EXIT:
     229                 :         return;
     230                 : }
     231                 : 
     232                 : /* ------------------------------------------------------------------------- */
     233                 : void tx_prepend (Text * src, Text * dest)
     234               0 : {
     235               0 :         Text *tmp=INITPTR;
     236               0 :         if( src==INITPTR || dest == INITPTR ) return;
     237               0 :         tmp=src;
     238               0 :         src=dest;
     239               0 :         dest=tmp;
     240               0 :         tx_append(src,dest);
     241                 : }
     242                 : 
     243                 : /* ------------------------------------------------------------------------- */
     244                 : void tx_c_prepend (Text * src, const char * dest)
     245             108 : {
     246             108 :         Text *tmp=INITPTR;
     247             108 :         if( src==INITPTR || dest == INITPTR ) return;
     248             108 :         tmp = tx_create(dest);
     249             108 :         tx_append(tmp,src);
     250             108 :         tx_copy(src,tmp);
     251             108 :         tx_destroy (&tmp);
     252                 : }
     253                 : 
     254                 : /* ------------------------------------------------------------------------- */
     255                 : void tx_c_copy (Text * dest, const char *src)
     256             136 : {
     257             136 :         unsigned int    slen = 0;
     258             136 :         unsigned int    tmp = 0;
     259                 : 
     260             136 :         if (dest == INITPTR) {
     261               2 :                 goto EXIT;
     262                 :         }
     263             134 :         if (src == INITPTR) {
     264               1 :                 goto EXIT;
     265                 :         }
     266             133 :         if (dest->buf_ == src) {
     267               0 :                 goto EXIT;
     268                 :         }
     269                 : 
     270             133 :         slen = strlen (src);
     271             133 :         tmp = ((int)((float)slen / (float)MaxTextBufferSize)) + 1;
     272             133 :         DELETE (dest->buf_);
     273                 : 
     274             133 :         dest->max_size_ = tmp * MaxTextBufferSize;
     275             133 :         dest->buf_ = NEW2 (char, dest->max_size_);
     276             133 :         memset (dest->buf_, '\0', dest->max_size_);
     277             133 :         dest->size_ = slen;
     278                 : 
     279             133 :         STRCPY (dest->buf_, src, slen);
     280             136 :       EXIT:
     281                 :         return;
     282                 : }
     283                 : 
     284                 : /* ------------------------------------------------------------------------- */
     285                 : char           *tx_get_buf (Text * txt)
     286          122370 : {
     287                 :         char           *retval;
     288          122370 :         if (txt == INITPTR) {
     289               0 :                 return INITPTR;
     290                 :         } else {
     291          122370 :                 retval = NEW2 (char, txt->size_ + 1);
     292          122370 :                 STRCPY (retval, txt->buf_, txt->size_ + 1);
     293          122370 :                 return retval;
     294                 :         }
     295                 : }
     296                 : 
     297                 : /* ------------------------------------------------------------------------- */
     298                 : char           *tx_share_buf (Text * txt)
     299           38483 : {
     300           38483 :         if (txt == INITPTR) {
     301               0 :                 return INITPTR;
     302                 :         } else {
     303           38483 :                 return txt->buf_;
     304                 :         }
     305                 : }
     306                 : 
     307                 : /* ------------------------------------------------------------------------- */
     308                 : void tx_back_trim (Text * txt, const char *chars)
     309          122351 : {
     310          122351 :         char           *c = INITPTR;
     311          122351 :         int             tmp = 0;
     312          122351 :         int             tmp2 = 0;
     313          122351 :         if (txt == INITPTR) {
     314               0 :                 return;
     315                 :         }
     316          122351 :         if (chars == INITPTR) {
     317               0 :                 return;
     318                 :         }
     319          122351 :         if (txt->size_ == 0) {
     320           14266 :                 return;
     321                 :         }
     322          108085 :         tmp = ((int)((float)txt->size_ / (float)MaxTextBufferSize)) + 1;
     323          108085 :         c = &txt->buf_[txt->size_ - 1];
     324          219612 :         while (strchr (chars, *c) != NULL && c != &txt->buf_[0]) {
     325            3442 :                 c--;
     326                 :         }
     327          108085 :         *(c + 1) = '\0';
     328          108085 :         txt->size_ = strlen (txt->buf_);
     329          108085 :         tmp2 = ((int)((float)txt->size_ / (float)MaxTextBufferSize)) + 1;
     330          108085 :         if (tmp != tmp2) {
     331               0 :                 txt->max_size_ = tmp2 * MaxTextBufferSize;
     332               0 :                 c = NEW2 (char, txt->max_size_);
     333               0 :                 memset (c, '\0', txt->max_size_);
     334               0 :                 STRCPY (c, txt->buf_, txt->size_);
     335               0 :                 DELETE (txt->buf_);
     336               0 :                 txt->buf_ = c;
     337                 :         }
     338                 : }
     339                 : 
     340                 : /* ------------------------------------------------------------------------- */
     341                 : char tx_at (Text * txt, unsigned int index)
     342               0 : {
     343               0 :         if(txt==INITPTR || index>=txt->size_) return '\0';
     344               0 :         else return txt->buf_[index];
     345                 : }
     346                 : 
     347                 : /* ------------------------------------------------------------------------- */
     348                 : void tx_int_append(Text * dest,const char *flags, int src)
     349           28993 : {
     350                 :         /* assumed that there will be no number longer than 63 digits */
     351                 :         char tmp[64];
     352                 :         char format[64];
     353           28993 :         if (dest==INITPTR) { return; }
     354           28993 :         memset(tmp,'\0',64);
     355           28993 :         memset(format,'\0',64);
     356           28993 :         sprintf(format,"%%%sd",flags);
     357           28993 :         sprintf(tmp,format,src);
     358           28993 :         tx_c_append(dest,tmp);
     359                 : }
     360                 : 
     361                 : /* ------------------------------------------------------------------------- */
     362                 : /* ================= OTHER EXPORTED FUNCTIONS ============================== */
     363                 : /* None */
     364                 : 
     365                 : /* ------------------------------------------------------------------------- */
     366                 : /* ================= TESTS FOR LOCAL FUNCTIONS ============================= */
     367                 : #ifdef MIN_UNIT_TEST
     368                 : #include "text.tests"
     369                 : #endif                          /* MIN_UNIT_TEST */
     370                 : /* ------------------------------------------------------------------------- */
     371                 : /* End of file */

Generated by: LTP GCOV extension version 1.6