Return to String.c CVS log

Up to [Research Unix] / researchv10no / cmd / cfront / demangle

Annotation of researchv10no/cmd/cfront/demangle/String.c, revision 1.1.1.1

1.1       root        1: /*ident        "@(#)ctrans:demangler/String.c  1.2"*/
                      2: /*
                      3:  * C++ Demangler Source Code
                      4:  * @(#)master  1.5
                      5:  * 7/27/88 13:54:37
                      6:  */
                      7: #include "String.h"
                      8: #include <stdio.h>
                      9: #include <assert.h>
                     10: extern char *malloc();
                     11: /* This code emulates the C++ String package
                     12:  * in a crude way.
                     13:  */
                     14: 
                     15: /* This function will expand the space
                     16:  * availabe to a String so that more data
                     17:  * can be appended to it
                     18:  */
                     19: static String *
                     20: grow(s)
                     21: String *s;
                     22: {
                     23:        int sz = s->sg.max * 2;
                     24:        assert(sz > 0);
                     25:        s = (String *)realloc(s,sz + sizeof(StringGuts)+1);
                     26:        assert(s != 0);
                     27:        s->sg.max = sz;
                     28:        return s;
                     29: }
                     30: 
                     31: /* This function will expand the space
                     32:  * available to a String so that more data
                     33:  * can be prepended to it.
                     34:  */
                     35: static String *
                     36: ror(s,n)
                     37: String *s;
                     38: int n;
                     39: {
                     40:        int i;
                     41:        assert(s != 0);
                     42:        while(s->sg.end + n > s->sg.max)
                     43:                s = grow(s);
                     44:        for(i = s->sg.end - 1;i >= s->sg.start;i--)
                     45:                s->data[i+n] = s->data[i];
                     46:        s->sg.end += n;
                     47:        s->sg.start += n;
                     48:        s->data[s->sg.end] = 0;
                     49:        return s;
                     50: }
                     51: 
                     52: /* This function will prepend c
                     53:  * to s
                     54:  */
                     55: String *
                     56: prep_String(c,s)
                     57: char *c;
                     58: String *s;
                     59: {
                     60:        int n = strlen(c);
                     61:        return nprep_String(c,s,n);
                     62: }
                     63: 
                     64: /* This function will prepend the
                     65:  * first n characters of c to s
                     66:  */
                     67: String *
                     68: nprep_String(c,s,n)
                     69: char *c;
                     70: String *s;
                     71: int n;
                     72: {
                     73:        int len = strlen(c);
                     74:        assert(s != 0);
                     75:        if(len > n)
                     76:                len = n;
                     77:        if(len >= s->sg.start)
                     78:                s = ror(s,len);
                     79:        while(len--)
                     80:                s->data[--(s->sg.start)] = c[len];
                     81:        s->data[s->sg.end] = '\0';
                     82:        return s;
                     83: }
                     84: 
                     85: /* This function will append
                     86:  * c to s.
                     87:  */
                     88: String *
                     89: app_String(s,c)
                     90: String *s;
                     91: char *c;
                     92: {
                     93:        int n = strlen(c);
                     94:        s = napp_String(s,c,n);
                     95:        return s;
                     96: }
                     97: 
                     98: /* This function will append the
                     99:  * first n characters of c to s
                    100:  */
                    101: String *
                    102: napp_String(s,c,n)
                    103: String *s;
                    104: char *c;
                    105: {
                    106:        int len = strlen(c);
                    107:        int catlen;
                    108:        assert(s != 0);
                    109:        if(n < len)
                    110:                len = n;
                    111:        catlen = s->sg.end + len;
                    112:        while(catlen > s->sg.max)
                    113:                s = grow(s);
                    114:        while(len--)
                    115:                s->data[s->sg.end++] = *c++;
                    116:        s->data[s->sg.end] = '\0';
                    117:        assert(s->sg.end == catlen);
                    118:        return s;
                    119: }
                    120: 
                    121: /* This function initializes a
                    122:  * String.  It returns
                    123:  * its argument is non-zero.
                    124:  * This prevents the same string
                    125:  * from being re-initialized.
                    126:  */
                    127: String *
                    128: mk_String(s)
                    129: String *s;
                    130: {
                    131:        if(s)
                    132:                return s;
                    133:        s = (String *)malloc(STRING_START + sizeof(StringGuts)+1);
                    134:        assert(s != 0);
                    135:        s->sg.start = s->sg.end = STRING_START/2;
                    136:        s->sg.max = STRING_START;
                    137:        s->data[s->sg.end] = '\0';
                    138:        return s;
                    139: }
                    140: 
                    141: void
                    142: free_String(s)
                    143: String *s;
                    144: {
                    145:        if(s) free(s);
                    146: }
                    147: 
                    148: /* This function copies
                    149:  * c into s
                    150:  */
                    151: String *
                    152: set_String(s,c)
                    153: String *s;
                    154: char *c;
                    155: {
                    156:        int len = strlen(c)*2;
                    157:        while(len > s->sg.max)
                    158:                s = grow(s);
                    159:        s->sg.start = s->sg.end = s->sg.max / 2;
                    160:        s = app_String(s,c);
                    161:        return s;
                    162: }

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