![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to replace.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / e / bin / pax|
Return to replace.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / pax |
1.1 root 1: /* $Source: /src386/usr/bin/pax/replace.c,v $
2: *
3: * $Revision: 1.1 $
4: *
5: * replace.c - regular expression pattern replacement functions
6: *
7: * DESCRIPTION
8: *
9: * These routines provide for regular expression file name replacement
10: * as required by pax.
11: *
12: * AUTHORS
13: *
14: * Mark H. Colburn, NAPS International
15: *
16: * Sponsored by The USENIX Association for public distribution.
17: *
18: * Copyright (c) 1989 Mark H. Colburn.
19: * All rights reserved.
20: *
21: * Redistribution and use in source and binary forms are permitted
22: * provided that the above copyright notice is duplicated in all such
23: * forms and that any documentation, advertising materials, and other
24: * materials related to such distribution and use acknowledge that the
25: * software was developed * by Mark H. Colburn and sponsored by The
26: * USENIX Association.
27: *
28: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
29: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
30: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
31: *
32: * $Log: replace.c,v $
33: * Revision 1.1 92/08/28 08:03:04 bin
34: * Initial revision
35: *
36: * Revision 1.1 89/02/14 16:48:45 jep
37: * Initial revision
38: *
39: * Revision 1.1 88/12/23 18:02:36 mark
40: * Initial revision
41: *
42: */
43:
44: #ifndef lint
45: static char *ident = "$Id: replace.c,v 1.1 92/08/28 08:03:04 bin Exp Locker: bin $";
46: static char *copyright = "Copyright (c) 1989 Mark H. Colburn.\nAll rights reserved.\n";
47: #endif /* not lint */
48:
49: /* Headers */
50:
51: #include "pax.h"
52:
53:
54: /* add_replstr - add a replacement string to the replacement string list
55: *
56: * DESCRIPTION
57: *
58: * Add_replstr adds a replacement string to the replacement string
59: * list which is applied each time a file is about to be processed.
60: *
61: * PARAMETERS
62: *
63: * char *pattern - A regular expression which is to be parsed
64: */
65:
66: #if __STDC__
67:
68: void add_replstr(char *pattern)
69:
70: #else
71:
72: void add_replstr(pattern)
73: char *pattern;
74:
75: #endif
76: {
77: char *p;
78: char sep;
79: Replstr *rptr;
80: int len;
81:
82: if ((len = strlen(pattern)) < 4) {
83: warn("Replacement string not added",
84: "Malformed substitution syntax");
85: return;
86: }
87: if ((rptr = (Replstr *) malloc(sizeof(Replstr))) == (Replstr *)NULL) {
88: warn("Replacement string not added", "No space");
89: return;
90: }
91:
92: /* First character is the delimeter... */
93: sep = *pattern;
94:
95: /* Get trailing g and/or p */
96: p = pattern + len - 1;
97: while (*p != sep) {
98: if (*p == 'g') {
99: rptr->global = 1;
100: } else if (*p == 'p') {
101: rptr->print = 1;
102: } else {
103: warn(p, "Invalid RE modifier");
104: }
105: p--;
106: }
107:
108: if (*p != sep) {
109: warn("Replacement string not added", "Bad delimeters");
110: free(rptr);
111: return;
112: }
113: /* strip off leading and trailing delimeter */
114: *p = '\0';
115: pattern++;
116:
117: /* find the separating '/' in the pattern */
118: p = pattern;
119: while (*p) {
120: if (*p == sep) {
121: break;
122: }
123: if (*p == '\\' && *(p + 1) != '\0') {
124: p++;
125: }
126: p++;
127: }
128: if (*p != sep) {
129: warn("Replacement string not added", "Bad delimeters");
130: free(rptr);
131: return;
132: }
133: *p++ = '\0';
134:
135: /*
136: * Now pattern points to 'old' and p points to 'new' and both are '\0'
137: * terminated
138: */
139: if ((rptr->comp = regcomp(pattern)) == (regexp *)NULL) {
140: warn("Replacement string not added", "Invalid RE");
141: free(rptr);
142: return;
143: }
144: rptr->replace = p;
145: rptr->next = (Replstr *)NULL;
146: if (rplhead == (Replstr *)NULL) {
147: rplhead = rptr;
148: rpltail = rptr;
149: } else {
150: rpltail->next = rptr;
151: rpltail = rptr;
152: }
153: }
154:
155:
156:
157: /* rpl_name - possibly replace a name with a regular expression
158: *
159: * DESCRIPTION
160: *
161: * The string name is searched for in the list of regular expression
162: * substituions. If the string matches any of the regular expressions
163: * then the string is modified as specified by the user.
164: *
165: * PARAMETERS
166: *
167: * char *name - name to search for and possibly modify
168: */
169:
170: #if __STDC__
171:
172: void rpl_name(char *name)
173:
174: #else
175:
176: void rpl_name(name)
177: char *name;
178:
179: #endif
180: {
181: int found = 0;
182: int ret;
183: Replstr *rptr;
184: char buff[PATH_MAX + 1];
185: char buff1[PATH_MAX + 1];
186: char buff2[PATH_MAX + 1];
187: char *p;
188: char *b;
189:
190: strcpy(buff, name);
191: for (rptr = rplhead; !found && rptr != (Replstr *)NULL; rptr = rptr->next) {
192: do {
193: if ((ret = regexec(rptr->comp, buff)) != 0) {
194: p = buff;
195: b = buff1;
196: while (p < rptr->comp->startp[0]) {
197: *b++ = *p++;
198: }
199: p = rptr->replace;
200: while (*p) {
201: *b++ = *p++;
202: }
203: strcpy(b, rptr->comp->endp[0]);
204: found = 1;
205: regsub(rptr->comp, buff1, buff2);
206: strcpy(buff, buff2);
207: }
208: } while (ret && rptr->global);
209: if (found) {
210: if (rptr->print) {
211: fprintf(stderr, "%s >> %s\n", name, buff);
212: }
213: strcpy(name, buff);
214: }
215: }
216: }
217:
218:
219: /* get_disposition - get a file disposition
220: *
221: * DESCRIPTION
222: *
223: * Get a file disposition from the user. If the user enters 'y'
224: * the the file is processed, anything else and the file is ignored.
225: * If the user enters EOF, then the PAX exits with a non-zero return
226: * status.
227: *
228: * PARAMETERS
229: *
230: * char *mode - string signifying the action to be taken on file
231: * char *name - the name of the file
232: *
233: * RETURNS
234: *
235: * Returns 1 if the file should be processed, 0 if it should not.
236: */
237:
238: #if __STDC__
239:
240: int get_disposition(char *mode, char *name)
241:
242: #else
243:
244: int get_disposition(mode, name)
245: char *mode;
246: char *name;
247:
248: #endif
249: {
250: char ans[2];
251: char buf[PATH_MAX + 10];
252:
253: if (f_disposition) {
254: sprintf(buf, "%s %s? ", mode, name);
255: if (nextask(buf, ans, sizeof(ans)) == -1 || ans[0] == 'q') {
256: exit(0);
257: }
258: if (strlen(ans) == 0 || ans[0] != 'y') {
259: return(1);
260: }
261: }
262: return(0);
263: }
264:
265:
266: /* get_newname - prompt the user for a new filename
267: *
268: * DESCRIPTION
269: *
270: * The user is prompted with the name of the file which is currently
271: * being processed. The user may choose to rename the file by
272: * entering the new file name after the prompt; the user may press
273: * carriage-return/newline, which will skip the file or the user may
274: * type an 'EOF' character, which will cause the program to stop.
275: *
276: * PARAMETERS
277: *
278: * char *name - filename, possibly modified by user
279: * int size - size of allowable new filename
280: *
281: * RETURNS
282: *
283: * Returns 0 if successfull, or -1 if an error occurred.
284: *
285: */
286:
287: #if __STDC__
288:
289: int get_newname(char *name, int size)
290:
291: #else
292:
293: int get_newname(name, size)
294: char *name;
295: int size;
296:
297: #endif
298: {
299: char buf[PATH_MAX + 10];
300:
301: if (f_interactive) {
302: sprintf(buf, "rename %s? ", name);
303: if (nextask(buf, name, size) == -1) {
304: exit(0);
305: }
306: if (strlen(name) == 0) {
307: return(1);
308: }
309: }
310: return(0);
311: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.