![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to getprm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / uucp|
Return to getprm.c CVS log | Up to [Research Unix] / researchv10no / cmd / uucp |
1.1 root 1: /* /sccs/src/cmd/uucp/s.getprm.c
2: getprm.c 1.4 8/30/84 17:37:22
3: */
4: #include "uucp.h"
5: VERSION(@(#)getprm.c 1.4)
6:
7: #define LQUOTE '('
8: #define RQUOTE ')'
9:
10: #define ZERO 0
11: #define WHITE 1
12: #define DELIMIT 2
13: #define QUOTE 3
14: #define OTHER 9
15:
16:
17: extern char *bal();
18:
19: /*
20: * get next parameter from s
21: * s -> string to scan
22: * prm -> pointer to use to return token
23: * return:
24: * s -> pointer to next character
25: * NULL at end
26: */
27: char *
28: getprm(s, prm)
29: register char *s, *prm;
30: {
31: register char *c;
32: char rightq; /* the right quote character */
33:
34: /* skip white space */
35: while (charType(*s) == WHITE)
36: s++;
37:
38: *prm = '\0';
39: if (*s == '\0')
40: return(NULL);
41:
42: if (charType(*s) == DELIMIT) {
43: *prm++ = *s++;
44: *prm = '\0';
45: return(s);
46: }
47:
48: /* look for quoted argument */
49: if (charType(*s) == QUOTE) {
50: /* setup the right quote character */
51: if (*s == LQUOTE)
52: rightq = RQUOTE;
53: else
54: rightq = *s;
55:
56: c = bal(s, rightq);
57: (void) strcpy(prm, s, c-s+1);
58: prm[c-s+1] = '\0';
59: if ( *(s=c) == rightq) /* if end of string don't increment */
60: s++;
61: return(s);
62: }
63:
64: while (charType(*s) == OTHER)
65: *prm++ = *s++;
66: *prm = '\0';
67:
68: return(s);
69: }
70:
71: /*
72: * split name into system and file part
73: * name -> string to scan
74: * sys -> return area for system name
75: * rest -> return area for remainder
76: * return:
77: * 0 -> no system prefix
78: * TRUE -> system prefix return in sys
79: */
80:
81: split(name, sys, rest)
82: register char *name;
83: char *sys, *rest;
84: {
85: register char *c, *n;
86:
87: *sys = '\0';
88: if (*name == LQUOTE) {
89: c = bal(name, RQUOTE);
90: name++;
91: (void) strncpy(rest, name, c-name);
92: rest[c-name] = '\0';
93: return(0);
94: }
95:
96: for (n = name ;; n = c+1) { /* loop to get rid if initial Mynames */
97: if ((c = strchr(n, '!')) == NULL) {
98: (void) strcpy(rest, n);
99: return(0);
100: }
101:
102: /* ignore escaped '!' */
103: if ((c != n) && (*(c-1) == '\\')) {
104: *(c-1) = '\0';
105: (void) strcpy(rest, n);
106: (void) strcat(rest, c);
107: return(0);
108: }
109:
110: *c = '\0';
111: if (EQUALS(n, Myname)) /* initial system is Myname */
112: continue;
113:
114: (void) strcpy(sys, n);
115: (void) strcpy(rest, ++c);
116: return(TRUE);
117: }
118: /*NOTREACHED*/
119: }
120:
121:
122: /*
123: * bal - get balanced quoted string
124: *
125: * s - input string
126: * r - right quote
127: * Note: *s is the left quote
128: * return:
129: * pointer to the end of the quoted string
130: * Note:
131: * If the string is not balanced, it returns a pointer to the
132: * end of the string.
133: */
134:
135: char *
136: bal(s, r)
137: register char *s;
138: char r;
139: {
140: short count = 1;
141: char l; /* left quote character */
142:
143: for (l = *s++; *s; s++) {
144: if (*s == r) {
145: if (--count == 0)
146: break; /* this is the balanced end */
147: }
148: else if (*s == l)
149: count++;
150: }
151: return(s);
152: }
153:
154:
155: /*
156: * charType - classify type of character , white space, delimiter, other
157: *
158: * s - character
159: * return:
160: * WHITE - whitespace
161: * DELIMIT - delimiter
162: * QUOTE - some type of quote "'(`
163: * OTHER - other
164: */
165:
166: charType(s)
167: char s;
168: {
169: switch(s) {
170: case '>':
171: case '<':
172: case '|':
173: case ';':
174: case '&':
175: case '^':
176: case '\\':
177: return(DELIMIT);
178:
179: case ' ':
180: case '\t':
181: case '\n':
182: return(WHITE);
183:
184: case '\0':
185: return(ZERO);
186:
187:
188: case '"':
189: case '\'':
190: case '`':
191: case LQUOTE:
192: return(QUOTE);
193:
194: default:
195: return(OTHER);
196: }
197: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.