Return to regsub.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / lib / libc / gen / regexp

Annotation of 43BSDReno/lib/libc/gen/regexp/regsub.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * regsub
                      3:  *
                      4:  *     Copyright (c) 1986 by University of Toronto.
                      5:  *     Written by Henry Spencer.  Not derived from licensed software.
                      6:  *
                      7:  *     Permission is granted to anyone to use this software for any
                      8:  *     purpose on any computer system, and to redistribute it freely,
                      9:  *     subject to the following restrictions:
                     10:  *
                     11:  *     1. The author is not responsible for the consequences of use of
                     12:  *             this software, no matter how awful, even if they arise
                     13:  *             from defects in it.
                     14:  *
                     15:  *     2. The origin of this software must not be misrepresented, either
                     16:  *             by explicit claim or by omission.
                     17:  *
                     18:  *     3. Altered versions must be plainly marked as such, and must not
                     19:  *             be misrepresented as being the original software.
                     20:  */
                     21: #include <stdio.h>
                     22: #include <regexp.h>
                     23: #include "regmagic.h"
                     24: 
                     25: #ifndef CHARBITS
                     26: #define        UCHARAT(p)      ((int)*(unsigned char *)(p))
                     27: #else
                     28: #define        UCHARAT(p)      ((int)*(p)&CHARBITS)
                     29: #endif
                     30: 
                     31: /*
                     32:  - regsub - perform substitutions after a regexp match
                     33:  */
                     34: void
                     35: regsub(prog, source, dest)
                     36: regexp *prog;
                     37: char *source;
                     38: char *dest;
                     39: {
                     40:        register char *src;
                     41:        register char *dst;
                     42:        register char c;
                     43:        register int no;
                     44:        register int len;
                     45:        extern char *strncpy();
                     46: 
                     47:        if (prog == NULL || source == NULL || dest == NULL) {
                     48:                regerror("NULL parm to regsub");
                     49:                return;
                     50:        }
                     51:        if (UCHARAT(prog->program) != MAGIC) {
                     52:                regerror("damaged regexp fed to regsub");
                     53:                return;
                     54:        }
                     55: 
                     56:        src = source;
                     57:        dst = dest;
                     58:        while ((c = *src++) != '\0') {
                     59:                if (c == '&')
                     60:                        no = 0;
                     61:                else if (c == '\\' && '0' <= *src && *src <= '9')
                     62:                        no = *src++ - '0';
                     63:                else
                     64:                        no = -1;
                     65:                if (no < 0) {   /* Ordinary character. */
                     66:                        if (c == '\\' && (*src == '\\' || *src == '&'))
                     67:                                c = *src++;
                     68:                        *dst++ = c;
                     69:                } else if (prog->startp[no] != NULL && prog->endp[no] != NULL) {
                     70:                        len = prog->endp[no] - prog->startp[no];
                     71:                        (void) strncpy(dst, prog->startp[no], len);
                     72:                        dst += len;
                     73:                        if (len != 0 && *(dst-1) == '\0') {     /* strncpy hit NUL. */
                     74:                                regerror("damaged match string");
                     75:                                return;
                     76:                        }
                     77:                }
                     78:        }
                     79:        *dst++ = '\0';
                     80: }

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