Return to string.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / cifplot

Annotation of 41BSD/cmd/cifplot/string.c, revision 1.1

1.1     ! root        1: /*******************************************************************
        !             2: *                                                                  *
        !             3: *    File: CIFPLOT/string.c                                        *
        !             4: *    Written by Dan Fitzpatrick                                    *
        !             5: *    copyright 1980 -- Regents of the University of California     *
        !             6: *                                                                  *
        !             7: ********************************************************************/
        !             8: 
        !             9: 
        !            10: #include <stdio.h>
        !            11: #include "defs.h"
        !            12: #include "globals.h"
        !            13: 
        !            14: IMPORT alloc();
        !            15: 
        !            16: string
        !            17: CatString(s1,s2)
        !            18: string s1,s2;
        !            19: /* Concatenate 's1' & 's2' */
        !            20: {
        !            21:     string p;
        !            22:     int i,j;
        !            23:     p = (char *) alloc(LengthString(s1)+LengthString(s2)-1);
        !            24:     for (i=0; '\0' != (p[i] = s1[i]);) i++;
        !            25:     for (j=0; '\0' != (p[i++] = s2[j++]););
        !            26:     return(p);
        !            27:     }
        !            28: 
        !            29: string
        !            30: Concat(args)
        !            31: /* Concatenate an arbitrary number of arguments terminated by a 0 */
        !            32: {
        !            33:     string s,t;
        !            34:     union {
        !            35:        string *p;
        !            36:        int *a;
        !            37:        } x;
        !            38: 
        !            39:     s = CatString("","");
        !            40:     x.a = &args;
        !            41: 
        !            42:     while (*(x.p) != 0) {
        !            43:        t = CatString(s,*(x.p++));
        !            44:        Free(s);
        !            45:        s = t;
        !            46:        }
        !            47:     return(s);
        !            48:     }
        !            49: 
        !            50: LengthString(s)
        !            51: string s;
        !            52: /* Return the length of the string 's' */
        !            53: {
        !            54:     int i;
        !            55:     for (i=0; '\0' != s[i++];);
        !            56:     return(i+1);
        !            57:     }
        !            58: 
        !            59: string 
        !            60: MakeString(c)
        !            61: char c;
        !            62: /* Return a string that contains only the character in 'c' */
        !            63: {
        !            64:     char s[2];
        !            65:     s[0] = c;
        !            66:     s[1] = '\0';
        !            67:     return(Concat(s,0));
        !            68:     }
        !            69: 
        !            70: char *
        !            71: strip(s)
        !            72: char *s;
        !            73: /* Returns a pointer to the string of characters in 's'
        !            74:  * without leading or trailing white spaces */
        !            75: {
        !            76:    char *t;
        !            77:    while (*s == ' ' || *s == '\t' || *s == '\n') s++;
        !            78:    t = s;
        !            79:    while (*t != ' ' && *t != '\t' && *t != '\n' && *t != 0) t++;
        !            80:    *t = 0;
        !            81:    return(s);
        !            82:    }
        !            83: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.