LCOV - code coverage report
Current view: top level - soltools/cpp - _tokens.c (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 105 232 45.3 %
Date: 2015-06-13 12:38:46 Functions: 12 16 75.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <stdio.h>
      21             : #include <stdlib.h>
      22             : #include <string.h>
      23             : #include <ctype.h>
      24             : #if (defined(_WIN32) || defined(__IBMC__))
      25             : #include <io.h>
      26             : #else
      27             : #include <unistd.h>
      28             : #endif
      29             : #include "cpp.h"
      30             : 
      31             : 
      32             : static char wbuf[4 * OBS];
      33             : static char *wbp = wbuf;
      34             : static int EBCDIC_ExternTokenDetected = 0;
      35             : static int EBCDIC_StartTokenDetected = 0;
      36             : 
      37             : unsigned char toLatin1[256] =
      38             : {
      39             :     0x00, 0x01, 0x02, 0x03, 0x9c, 0x09, 0x86, 0x7f, 0x97, 0x8d,
      40             :     0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
      41             :     0x9d, 0x0a, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8f, 0x1c, 0x1d,
      42             :     0x1e, 0x1f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x17, 0x1b,
      43             :     0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07, 0x90, 0x91,
      44             :     0x16, 0x93, 0x94, 0x95, 0x96, 0x04, 0x98, 0x99, 0x9a, 0x9b,
      45             :     0x14, 0x15, 0x9e, 0x1a, 0x20, 0xa0, 0xe2, 0xe4, 0xe0, 0xe1,
      46             :     0xe3, 0xe5, 0xe7, 0xf1, 0xa2, 0x2e, 0x3c, 0x28, 0x2b, 0x7c,
      47             :     0x26, 0xe9, 0xea, 0xeb, 0xe8, 0xed, 0xee, 0xef, 0xec, 0xdf,
      48             :     0x21, 0x24, 0x2a, 0x29, 0x3b, 0x5e, 0x2d, 0x2f, 0xc2, 0xc4,
      49             :     0xc0, 0xc1, 0xc3, 0xc5, 0xc7, 0xd1, 0xa6, 0x2c, 0x25, 0x5f,
      50             :     0x3e, 0x3f, 0xf8, 0xc9, 0xca, 0xcb, 0xc8, 0xcd, 0xce, 0xcf,
      51             :     0xcc, 0x60, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22,
      52             :     0xd8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
      53             :     0xab, 0xbb, 0xf0, 0xfd, 0xfe, 0xb1, 0xb0, 0x6a, 0x6b, 0x6c,
      54             :     0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0xaa, 0xba, 0xe6, 0xb8,
      55             :     0xc6, 0xa4, 0xb5, 0x7e, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
      56             :     0x79, 0x7a, 0xa1, 0xbf, 0xd0, 0x5b, 0xde, 0xae, 0xac, 0xa3,
      57             :     0xa5, 0xb7, 0xa9, 0xa7, 0xb6, 0xbc, 0xbd, 0xbe, 0xdd, 0xa8,
      58             :     0xaf, 0x5d, 0xb4, 0xd7, 0x7b, 0x41, 0x42, 0x43, 0x44, 0x45,
      59             :     0x46, 0x47, 0x48, 0x49, 0xad, 0xf4, 0xf6, 0xf2, 0xf3, 0xf5,
      60             :     0x7d, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52,
      61             :     0xb9, 0xfb, 0xfc, 0xf9, 0xfa, 0xff, 0x5c, 0xf7, 0x53, 0x54,
      62             :     0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0xb2, 0xd4, 0xd6, 0xd2,
      63             :     0xd3, 0xd5, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
      64             :     0x38, 0x39, 0xb3, 0xdb, 0xdc, 0xd9, 0xda, 0x9f
      65             : };
      66             : 
      67             : #define MASK    "\\x%x"
      68             : 
      69             : int
      70           0 :     memcpy_EBCDIC( char * pwbuf, uchar *p, int len )
      71             : {
      72           0 :     int currpos = 0;
      73           0 :     int processedchars = 0;
      74             : 
      75           0 :     if( len == 0 )
      76           0 :         return 0;
      77             : 
      78           0 :     if( len == 1 )
      79             :     {
      80           0 :         *pwbuf = *p;
      81           0 :         return 1;
      82             :     }
      83             : 
      84             :     /* copy spaces until " or ' */
      85           0 :     while( (p[ processedchars ] != '\"') && (p[ processedchars ] != '\'') )
      86           0 :         pwbuf[ currpos++ ] = p[ processedchars++ ];
      87             : 
      88             :     /* copy first " or ' */
      89           0 :     pwbuf[ currpos++ ] = p[ processedchars++ ];
      90             : 
      91             :     /* convert all characters until " or ' */
      92           0 :     while( processedchars < (len - 1) )
      93             :     {
      94           0 :         if( p[ processedchars ] == '\\' )
      95             :         {
      96           0 :             switch( p[ ++processedchars ] )
      97             :             {
      98             :                 case 'n':
      99           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\n'] );
     100           0 :                     processedchars++;
     101           0 :                     break;
     102             : 
     103             :                 case 't':
     104           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\t'] );
     105           0 :                     processedchars++;
     106           0 :                     break;
     107             : 
     108             :                 case 'v':
     109           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\v'] );
     110           0 :                     processedchars++;
     111           0 :                     break;
     112             : 
     113             :                 case 'b':
     114           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\b'] );
     115           0 :                     processedchars++;
     116           0 :                     break;
     117             : 
     118             :                 case 'r':
     119           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\r'] );
     120           0 :                     processedchars++;
     121           0 :                     break;
     122             : 
     123             :                 case 'f':
     124           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\f'] );
     125           0 :                     processedchars++;
     126           0 :                     break;
     127             : 
     128             :                 case 'a':
     129           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\a'] );
     130           0 :                     processedchars++;
     131           0 :                     break;
     132             : 
     133             :                 case '\\':
     134           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\\'] );
     135           0 :                     processedchars++;
     136           0 :                     break;
     137             : 
     138             :                 case '?':
     139           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\?'] );
     140           0 :                     processedchars++;
     141           0 :                     break;
     142             : 
     143             :                 case '\'':
     144           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\''] );
     145           0 :                     processedchars++;
     146           0 :                     break;
     147             : 
     148             :                 case '"':
     149           0 :                     currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1['\"'] );
     150           0 :                     processedchars++;
     151           0 :                     break;
     152             : 
     153             :                 /* octal coded character? -> copy */
     154             :                 case '0':
     155             :                 case '1':
     156             :                 case '2':
     157             :                 case '3':
     158             :                 case '4':
     159             :                 case '5':
     160             :                 case '6':
     161             :                 case '7':
     162             :                     {
     163           0 :                     int startpos = currpos;
     164             : 
     165           0 :                     pwbuf[ currpos++ ] = '\\';
     166             : 
     167           0 :                     while( p[ processedchars ] >= '0' && p[ processedchars ] <= '7' && (currpos < startpos + 4) )
     168           0 :                           pwbuf[ currpos++ ] = (unsigned char)p[ processedchars++ ];
     169           0 :                     break;
     170             :                     }
     171             : 
     172             :                 /* hex coded character? -> copy */
     173             :                 case 'x':
     174             :                 case 'X':
     175             :                     {
     176           0 :                     int startpos = currpos;
     177             : 
     178           0 :                     pwbuf[ currpos++ ] = '\\';
     179           0 :                     pwbuf[ currpos++ ] = 'x';
     180           0 :                     processedchars++;
     181             : 
     182           0 :                     while( isxdigit( p[ processedchars ] ) && (currpos < startpos + 4) )
     183           0 :                           pwbuf[ currpos++ ] = (unsigned char)p[ processedchars++ ];
     184           0 :                     break;
     185             :                     }
     186             : 
     187             :             }
     188             :         }
     189             :         else
     190           0 :             currpos += sprintf( &pwbuf[ currpos ], MASK, toLatin1[p[ processedchars++ ]] );
     191             : 
     192             :     }
     193             : 
     194             :     /* copy last " or ' */
     195           0 :     pwbuf[ currpos++ ] = p[ processedchars ];
     196             : 
     197           0 :     return currpos;
     198             : }
     199             : 
     200             : void
     201      398557 :     maketokenrow(int size, Tokenrow * trp)
     202             : {
     203      398557 :     trp->max = size;
     204      398557 :     if (size > 0)
     205      398556 :         trp->bp = (Token *) domalloc(size * sizeof(Token));
     206             :     else
     207           1 :         trp->bp = NULL;
     208      398557 :     trp->tp = trp->bp;
     209      398557 :     trp->lp = trp->bp;
     210      398557 : }
     211             : 
     212             : Token *
     213       71464 :     growtokenrow(Tokenrow * trp)
     214             : {
     215       71464 :     size_t ncur = trp->tp - trp->bp;
     216       71464 :     size_t nlast = trp->lp - trp->bp;
     217             : 
     218       71464 :     trp->max = 3 * trp->max / 2 + 1;
     219       71464 :     trp->bp = (Token *) realloc(trp->bp, trp->max * sizeof(Token));
     220       71464 :     trp->lp = &trp->bp[nlast];
     221       71464 :     trp->tp = &trp->bp[ncur];
     222       71464 :     return trp->lp;
     223             : }
     224             : 
     225             : /*
     226             :  * Compare a row of tokens, ignoring the content of WS; return !=0 if different
     227             :  */
     228             : int
     229           0 :     comparetokens(Tokenrow * tr1, Tokenrow * tr2)
     230             : {
     231             :     Token *tp1, *tp2;
     232             : 
     233           0 :     tp1 = tr1->tp;
     234           0 :     tp2 = tr2->tp;
     235           0 :     if (tr1->lp - tp1 != tr2->lp - tp2)
     236           0 :         return 1;
     237           0 :     for (; tp1 < tr1->lp; tp1++, tp2++)
     238             :     {
     239           0 :         if (tp1->type != tp2->type
     240           0 :             || (tp1->wslen == 0) != (tp2->wslen == 0)
     241           0 :             || tp1->len != tp2->len
     242           0 :             || strncmp((char *) tp1->t, (char *) tp2->t, tp1->len) != 0)
     243           0 :             return 1;
     244             :     }
     245           0 :     return 0;
     246             : }
     247             : 
     248             : /*
     249             :  * replace ntok tokens starting at dtr->tp with the contents of str.
     250             :  * tp ends up pointing just beyond the replacement.
     251             :  * Canonical whitespace is assured on each side.
     252             :  */
     253             : void
     254      301948 :     insertrow(Tokenrow * dtr, int ntok, Tokenrow * str)
     255             : {
     256      301948 :     int nrtok = (int)rowlen(str);
     257             : 
     258      301948 :     dtr->tp += ntok;
     259      301948 :     adjustrow(dtr, nrtok - ntok);
     260      301948 :     dtr->tp -= ntok;
     261      301948 :     movetokenrow(dtr, str);
     262      301948 :     dtr->tp += nrtok;
     263      301948 : }
     264             : 
     265             : /*
     266             :  * make sure there is WS before trp->tp, if tokens might merge in the output
     267             :  */
     268             : void
     269      292172 :     makespace(Tokenrow * trp, Token * ntp)
     270             : {
     271             :     uchar *tt;
     272      292172 :     Token *tp = trp->tp;
     273             : 
     274      292172 :     if (tp >= trp->lp)
     275      309846 :         return;
     276             : 
     277      274498 :     if (ntp->wslen)
     278             :     {
     279      194369 :         tt = newstring(tp->t, tp->len, ntp->wslen);
     280      194369 :         strncpy((char *)tt, (char *)ntp->t - ntp->wslen, ntp->wslen);
     281      194369 :         tp->t = tt + ntp->wslen;
     282      194369 :         tp->wslen = ntp->wslen;
     283      194369 :         tp->flag |= XPWS;
     284             :     }
     285             : }
     286             : 
     287             : /*
     288             :  * Copy an entire tokenrow into another, at tp.
     289             :  * It is assumed that there is enough space.
     290             :  *  Not strictly conforming.
     291             :  */
     292             : void
     293      576447 :     movetokenrow(Tokenrow * dtr, Tokenrow * str)
     294             : {
     295             :     size_t nby;
     296             : 
     297      576447 :     nby = (char *) str->lp - (char *) str->bp;
     298      576447 :     memmove(dtr->tp, str->bp, nby);
     299      576447 : }
     300             : 
     301             : /*
     302             :  * Move the tokens in a row, starting at tr->tp, rightward by nt tokens;
     303             :  * nt may be negative (left move).
     304             :  * The row may need to be grown.
     305             :  * Non-strictly conforming because of the (char *), but easily fixed
     306             :  */
     307             : void
     308      301948 :     adjustrow(Tokenrow * trp, int nt)
     309             : {
     310             :     size_t nby, size;
     311             : 
     312      301948 :     if (nt == 0)
     313      502982 :         return;
     314      100914 :     size = (trp->lp - trp->bp) + nt;
     315      245384 :     while (size > trp->max)
     316       43556 :         growtokenrow(trp);
     317      100914 :     nby = (char *) trp->lp - (char *) trp->tp;
     318      100914 :     if (nby)
     319       54692 :         memmove(trp->tp + nt, trp->tp, nby);
     320      100914 :     trp->lp += nt;
     321             : }
     322             : 
     323             : /*
     324             :  * Copy a row of tokens into the destination holder, allocating
     325             :  * the space for the contents.  Return the destination.
     326             :  */
     327             : Tokenrow *
     328      274499 :     copytokenrow(Tokenrow * dtr, Tokenrow * str)
     329             : {
     330      274499 :     int len = (int)rowlen(str);
     331             : 
     332      274499 :     maketokenrow(len, dtr);
     333      274499 :     movetokenrow(dtr, str);
     334      274499 :     dtr->lp += len;
     335      274499 :     return dtr;
     336             : }
     337             : 
     338             : /*
     339             :  * Produce a copy of a row of tokens.  Start at trp->tp.
     340             :  * The value strings are copied as well.  The first token
     341             :  * has WS available.
     342             :  */
     343             : Tokenrow *
     344      100795 :     normtokenrow(Tokenrow * trp)
     345             : {
     346             :     Token *tp;
     347      100795 :     Tokenrow *ntrp = new(Tokenrow);
     348             :     int len;
     349             : 
     350      100795 :     len = (int)(trp->lp - trp->tp);
     351      100795 :     if (len <= 0)
     352         158 :         len = 1;
     353      100795 :     maketokenrow(len, ntrp);
     354     1224378 :     for (tp = trp->tp; tp < trp->lp; tp++)
     355             :     {
     356     1123583 :         *ntrp->lp = *tp;
     357     1123583 :         if (tp->len)
     358             :         {
     359     1123583 :             ntrp->lp->t = newstring(tp->t, tp->len, 1);
     360     1123583 :             *ntrp->lp->t++ = ' ';
     361     1123583 :             if (tp->wslen)
     362      280603 :                 ntrp->lp->wslen = 1;
     363             :         }
     364     1123583 :         ntrp->lp++;
     365             :     }
     366      100795 :     if (ntrp->lp > ntrp->bp)
     367      100637 :         ntrp->bp->wslen = 0;
     368      100795 :     return ntrp;
     369             : }
     370             : 
     371             : /*
     372             :  * Debugging
     373             :  */
     374             : void
     375           0 :     peektokens(Tokenrow * trp, char *str)
     376             : {
     377             :     Token *tp;
     378             : 
     379           0 :     tp = trp->tp;
     380           0 :     flushout();
     381           0 :     if (str)
     382           0 :         fprintf(stderr, "%s ", str);
     383           0 :     if (tp < trp->bp || tp > trp->lp)
     384           0 :         fprintf(stderr, "(tp offset %ld) ", (long int) (tp - trp->bp));
     385           0 :     for (tp = trp->bp; tp < trp->lp && tp < trp->bp + 32; tp++)
     386             :     {
     387           0 :         if (tp->type != NL)
     388             :         {
     389           0 :             int c = tp->t[tp->len];
     390             : 
     391           0 :             tp->t[tp->len] = 0;
     392           0 :             fprintf(stderr, "%s", tp->t);
     393           0 :             tp->t[tp->len] = (uchar) c;
     394             :         }
     395           0 :         fprintf(stderr, tp == trp->tp ? "{%x*} " : "{%x} ", tp->type);
     396             :     }
     397           0 :     fprintf(stderr, "\n");
     398           0 :     fflush(stderr);
     399           0 : }
     400             : 
     401             : void
     402       37834 :     puttokens(Tokenrow * trp)
     403             : {
     404             :     Token *tp;
     405             :     int len;
     406             :     uchar *p;
     407             : 
     408       37834 :     if (Vflag)
     409           0 :         peektokens(trp, "");
     410       37834 :     tp = trp->bp;
     411      713220 :     for (; tp < trp->lp; tp++)
     412             :     {
     413      675386 :         if (tp->type != NL)
     414             :         {
     415      637692 :             len = (int)(tp->len + tp->wslen);
     416      637692 :             p = tp->t - tp->wslen;
     417             : 
     418             :             /* add parameter check to delete operator? */
     419      637692 :             if( Dflag )
     420             :             {
     421           0 :                 if( (tp->type == NAME) && (strncmp( (char*)p, "delete", len ) == 0) )
     422             :                 {
     423           0 :                     Token* ntp = tp;
     424           0 :                     ntp++;
     425             : 
     426           0 :                     if( ntp->type == NAME )
     427             :                     {
     428           0 :                         uchar* np = ntp->t - ntp->wslen;
     429           0 :                         int nlen = (int)(ntp->len + ntp->wslen);
     430             : 
     431           0 :                         memcpy(wbp, "if(", 3 );
     432           0 :                          wbp += 4;
     433           0 :                         memcpy(wbp, np, nlen );
     434           0 :                          wbp += nlen;
     435           0 :                         memcpy(wbp, ")", 1 );
     436           0 :                          wbp++;
     437             : 
     438           0 :                         memcpy(wbp, p, len);
     439             :                     }
     440             :                 }
     441             :             }
     442             : 
     443             :             /* EBCDIC to ANSI conversion requested? */
     444      637692 :             if( Aflag )
     445             :             {
     446             :                 /* keyword __ToLatin1__ found? -> do conversion! */
     447           0 :                 if( EBCDIC_StartTokenDetected )
     448             :                 {
     449             :                     /* previous token was 'extern'? -> don't convert current token! */
     450           0 :                     if( EBCDIC_ExternTokenDetected )
     451             :                     {
     452           0 :                         EBCDIC_ExternTokenDetected = 0;
     453           0 :                         memcpy(wbp, p, len);
     454             :                     }
     455             :                     else
     456             :                     {
     457             :                         /* current token is keyword 'extern'? -> don't convert following token! */
     458           0 :                         if( (tp->wslen == 0) && (strncmp( (char*)p, "extern", len ) == 0) )
     459             :                         {
     460           0 :                             EBCDIC_ExternTokenDetected = 1;
     461           0 :                             memcpy(wbp, p, len);
     462             :                         }
     463             :                         else
     464             :                         {
     465             :                             /* token is string or char? -> process EBCDIC to ANSI conversion */
     466           0 :                             if ((tp->type == STRING) || (tp->type == CCON))
     467           0 :                                 len = memcpy_EBCDIC(wbp,  p, len);
     468             :                             else
     469           0 :                                 memcpy(wbp, p, len);
     470             :                         }
     471             :                     }
     472             :                 }
     473             :                 else
     474             :                     /* keyword __ToLatin1__ found? -> don't copy keyword and start conversion */
     475           0 :                     if( (tp->type == NAME) && (strncmp( (char*)p, "__ToLatin1__", len) == 0) )
     476             :                     {
     477           0 :                         EBCDIC_StartTokenDetected = 1;
     478           0 :                         len = 0;
     479             :                     }
     480             :                     else
     481           0 :                         memcpy(wbp, p, len);
     482             :             }
     483             :             else
     484      637692 :                 memcpy(wbp, p, len);
     485             : 
     486      637692 :             wbp += len;
     487             :         }
     488             :         else
     489       37694 :             *wbp++ = '\n';
     490             : 
     491      675386 :         if (wbp >= &wbuf[OBS])
     492             :         {
     493         504 :             if ( write(1, wbuf, OBS) != -1 ) {
     494         504 :             if (wbp > &wbuf[OBS])
     495         427 :                 memmove(wbuf, wbuf + OBS, wbp - &wbuf[OBS]);
     496         504 :             wbp -= OBS;
     497             :         }
     498           0 :         else exit(1);
     499             :         }
     500             :     }
     501       37834 :     trp->tp = tp;
     502       37834 :     if (cursource->fd == 0)
     503           0 :         flushout();
     504       37834 : }
     505             : 
     506             : void
     507          53 :     flushout(void)
     508             : {
     509          53 :     if (wbp > wbuf)
     510             :     {
     511          53 :         if ( write(1, wbuf, (int)(wbp - wbuf)) != -1)
     512          53 :             wbp = wbuf;
     513             :     else
     514           0 :         exit(1);
     515             :     }
     516          53 : }
     517             : 
     518             : /*
     519             :  * turn a row into just a newline
     520             :  */
     521             : void
     522       12791 :     setempty(Tokenrow * trp)
     523             : {
     524       12791 :     trp->tp = trp->bp;
     525       12791 :     trp->lp = trp->bp + 1;
     526       12791 :     *trp->bp = nltoken;
     527       12791 : }
     528             : 
     529             : /*
     530             :  * generate a number
     531             :  */
     532             : char *
     533           0 :     outnum(char *p, int n)
     534             : {
     535           0 :     if (n >= 10)
     536           0 :         p = outnum(p, n / 10);
     537           0 :     *p++ = (char) (n % 10 + '0');
     538           0 :     return p;
     539             : }
     540             : 
     541             : /*
     542             :  * allocate and initialize a new string from s, of length l, at offset o
     543             :  * Null terminated.
     544             :  */
     545             : uchar *
     546     1341527 :     newstring(uchar * s, size_t l, size_t o)
     547             : {
     548     1341527 :     uchar *ns = (uchar *) domalloc(l + o + 1);
     549             : 
     550     1341527 :     ns[l + o] = '\0';
     551     1341527 :     return (uchar *) strncpy((char *) ns + o, (char *) s, l) - o;
     552             : }
     553             : 
     554             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11