home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / proglang / dmake38a.arj / DMSTRING.C < prev    next >
C/C++ Source or Header  |  1992-01-23  |  7KB  |  303 lines
  1. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/dmstring.c,v 1.1 1992/01/24 03:29:38 dvadura Exp $
  2. -- SYNOPSIS -- string handling code
  3. -- 
  4. -- DESCRIPTION
  5. --    Routines to handle string manipulation.  This code is not specific
  6. --    to dmake and has/and will be used in other programs.  The string
  7. --    "" is considered the NULL string, if NIL(char) is received instead
  8. --    undefined results may occurr.  (In reality NIL(char) is checked for
  9. --    but in general it is not safe to assume NIL(char) ==  NULL)
  10. -- 
  11. -- AUTHOR
  12. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  13. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  14. --
  15. -- COPYRIGHT
  16. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  17. -- 
  18. --      This program is free software; you can redistribute it and/or
  19. --      modify it under the terms of the GNU General Public License
  20. --      (version 1), as published by the Free Software Foundation, and
  21. --      found in the file 'LICENSE' included with this distribution.
  22. -- 
  23. --      This program is distributed in the hope that it will be useful,
  24. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  25. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26. --      GNU General Public License for more details.
  27. -- 
  28. --      You should have received a copy of the GNU General Public License
  29. --      along with this program;  if not, write to the Free Software
  30. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31. --
  32. -- LOG
  33. --     $Log: dmstring.c,v $
  34.  * Revision 1.1  1992/01/24  03:29:38  dvadura
  35.  * dmake Version 3.8, Initial revision
  36.  *
  37. */
  38.  
  39. #include "extern.h"
  40.  
  41. PUBLIC char *
  42. _strjoin( src, data, n, fr )/*
  43. ==============================
  44.    Join data to src according to value of n.
  45.  
  46.       n = -1   - return strcat( src, data )
  47.       n >= 0   - return strncat( src, data, n )
  48.  
  49.    FREE original src if fr == TRUE, else leave it alone */
  50.  
  51. char *src;
  52. char *data;
  53. int  n;
  54. int  fr;
  55. {
  56.    char *t;
  57.    int  l;
  58.    int  flag = FALSE;
  59.  
  60.    DB_ENTER( "_strjoin" );
  61.    
  62.    if( src  == NIL(char) ) { src = ""; flag = TRUE; }
  63.    if( data == NIL(char) ) data = "";
  64.    DB_PRINT( "str", ("Joining [%s] [%s] %d", src, data, n) );
  65.  
  66.    if( n == -1 )  n = strlen( data );
  67.  
  68.    l = strlen( src ) + n + 1;
  69.    if( (t = MALLOC( l, char )) == NIL(char) ) No_ram();
  70.  
  71.    strcpy( t, src );
  72.    if (n) strncat( t, data, n );
  73.    t[ l-1 ] = '\0';
  74.  
  75.    if( !flag && fr ) FREE( src );
  76.  
  77.    DB_PRINT( "str", ("Result  [%s]", t) );
  78.    DB_RETURN( t );
  79. }
  80.  
  81.  
  82.  
  83.  
  84. PUBLIC char *
  85. _stradd( src, data, fr )/*
  86. ==========================
  87.    append data to src with space in between if src is not NIL(char) or ""
  88.    and free both src and data if fr == TRUE, otherwise leave them be */
  89.  
  90. char *src;
  91. char *data;
  92. int  fr;
  93. {
  94.    char *t;
  95.    int  l;
  96.    int  sflag;
  97.    int  dflag;
  98.  
  99.    DB_ENTER( "_stradd" );
  100.  
  101.    sflag = dflag = fr;
  102.  
  103.    if( src  == NIL(char) ) { src  = ""; sflag = FALSE; }
  104.    if( data == NIL(char) ) { data = ""; dflag = FALSE; }
  105.    DB_PRINT( "str", ("Adding [%s] [%s] %d", src, data, fr) );
  106.  
  107.    l = strlen(src) + strlen(data) + 1;
  108.    if( *src ) l++;
  109.  
  110.    if( (t = MALLOC( l, char )) == NIL(char) ) No_ram();
  111.  
  112.    strcpy( t, src );
  113.    
  114.    if( *data )
  115.    {
  116.       if( *src ) strcat( t,  " " );
  117.       strcat( t, data );
  118.    }
  119.  
  120.    if( sflag )  FREE( src  );
  121.    if( dflag )  FREE( data );
  122.  
  123.    DB_PRINT( "str", ("Result  [%s]", t) );
  124.    DB_RETURN( t );
  125. }
  126.  
  127.  
  128.  
  129. PUBLIC char *
  130. _strapp( src1, src2 )/*
  131. =======================
  132.    Append two strings together, and return the result with a space between
  133.    the two strings.  FREE the first string if it is not NIL and always
  134.    leave the second string be. */
  135. char *src1;
  136. char *src2;
  137. {
  138.    src2 = _stradd( src1, src2, FALSE );
  139.    if( src1 != NIL(char) ) FREE( src1 );
  140.    return( src2 );
  141. }
  142.  
  143.  
  144.  
  145. #ifdef DBUG
  146. #ifdef _strdup
  147. #undef _strdup
  148. #endif
  149. #endif
  150. PUBLIC char *
  151. _strdup( str )/*
  152. ================  Duplicate the contents of a string, by using malloc */
  153. char *str;
  154. {
  155.    char *t;
  156.  
  157.    if( str == NIL(char) ) return( NIL(char) );
  158.    
  159.    if( (t = MALLOC( strlen( str )+1, char )) == NIL(char) ) No_ram();
  160.    strcpy( t, str );
  161.  
  162.    return( t );
  163. }
  164.  
  165.  
  166.  
  167. PUBLIC char *
  168. _strdup2( str )/*
  169. =================
  170.    This function is used solely to properly quote command line arguments when
  171.    they are reinserted int MAKEMACROS so that they can be used further in
  172.    a processing line. */
  173. char *str;
  174. {
  175.    char *t;
  176.    size_t size;
  177.    size_t alloced;
  178.    char *tmp;
  179.    char *dest;
  180.    int seen_equal = 0;
  181.  
  182.    if(str == NIL(char)) return(NIL(char));
  183.    size = strlen(str) + 1;
  184.    alloced = size + 2;        /* for two quotes */
  185.  
  186.    for(tmp = str; *tmp; tmp++)
  187.       if(*tmp == '"')
  188.          alloced++;
  189.  
  190.    if((t = MALLOC(alloced, char)) == NIL(char)) No_ram();
  191.  
  192.    for(tmp = str, dest = t; *tmp; tmp++, dest++) {
  193.       if(*tmp == '=' && !seen_equal) {
  194.      seen_equal = 1;
  195.      *dest++ = *tmp;
  196.      *dest = '"';
  197.      continue;
  198.       }
  199.       if(*tmp == '"')
  200.      *dest++ = '\\';
  201.       *dest = *tmp;
  202.    }
  203.  
  204.    if(!seen_equal)
  205.       Fatal("_strdup2 invoked without argument of form x=y\n");
  206.  
  207.    *dest++ = '"';
  208.    *dest = 0;
  209.  
  210.    return t;
  211. }
  212.  
  213.  
  214.  
  215. PUBLIC char *
  216. _strpbrk( s1, s2 )/*
  217. ====================
  218.    find first occurence of char in s2 in string s1.
  219.    Returns a pointer to the first occurrence.  NOTE '\0' is considered part
  220.    of s2 and a pointer to it is returned if no other chars match. */
  221.  
  222. char *s1;
  223. char *s2;
  224. {
  225.    register char *t;
  226.  
  227.    if( s1 == NIL(char) || s2 == NIL(char) ) return( "" );
  228.  
  229.    for( t=s1; *t && (strchr( s2, *t ) == NIL(char)); t++ );
  230.    return( t );
  231. }
  232.  
  233.  
  234.  
  235.  
  236. PUBLIC char *
  237. _strspn( s1, s2 )/*
  238. ===================
  239.    return pointer to first char in s1 that does not belong to s2.
  240.    Returns the pointer if match found, else returns pointer to null char
  241.    in s1. (ie. "" ) */
  242.    
  243. char *s1;
  244. char *s2;
  245. {
  246.    register char *t;
  247.  
  248.    if( s1 == NIL(char) || s2 == NIL(char) ) return( "" );
  249.  
  250.    for( t=s1; *t && (strchr( s2, *t ) != NIL(char)); t++ );
  251.    return( t );
  252. }
  253.  
  254.  
  255.  
  256.  
  257. PUBLIC char *
  258. _strstr( s1, s2 )/*
  259. ==================  find first occurrence in s1 of s2 */
  260. char *s1;
  261. char *s2;
  262. {
  263.    register char *s;
  264.    register char *p;
  265.    register char *r;
  266.  
  267.    if( s1 != NIL(char) && s2 != NIL(char) )
  268.       for( s=s1; *s; s++ )
  269.      if( *s == *s2 )
  270.      {
  271.         for( r=s+1, p = s2+1; *p && (*r == *p); r++, p++ );
  272.         if( !*p ) return( s );
  273.      }
  274.    
  275.    return( NIL(char) );
  276. }
  277.  
  278.  
  279.  
  280. PUBLIC char *
  281. _substr( s, e )/*
  282. =================
  283.       Return the string between the two pointers s and e, not including the
  284.       char that e points to.  NOTE:  This routine assumes that s and e point
  285.       into the same string. */
  286.  
  287. char *s;
  288. char *e;
  289. {
  290.    char save;
  291.    int  len = e-s;
  292.  
  293.    if( len < 0 || len > strlen(s) )
  294.       Fatal( "Internal Error:  _substr fails consistency test" );
  295.  
  296.    save = *e;
  297.    *e   = '\0';
  298.    s    = _strdup( s );
  299.    *e   = save;
  300.  
  301.    return( s );
  302. }
  303.