![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vmswild.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / vi|
Return to vmswild.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /*
2: This 'C' module may be included prior to the ``main'' programs on VMS in
3: order to allow 'C' arguments to contain redirection symbols (<,>,>>) and
4: VMS wild cards (*,% ...], [-). By including this module, two programs
5: redirect() and expand() are run prior to turning control over to
6: your main() entry point.
7:
8: /*
9: redirect-- Gregg Townsend circa 1983,
10: expand-- John Campbell circa 1987
11:
12: This code is public domain, others may use it freely. Credit, however, to
13: Gregg Townsend (who wrote ``redirect()'') and John Campbell (who followed
14: with ``expand()'') would be appreciated. If someone writes the next
15: logical successor ``pipe()'', please email a copy to
16: ...!arizona!naucse!jdc (John Campbell) :-).
17: */
18:
19: #include <rms> /* No easy way to tell if this has already been included. */
20: #ifndef ERANGE /* Include only if missing. */
21: /* #include <stdlib> causes lots of warnings. */
22: #endif
23: #include <stdio.h> /* Stdio.h won't include itself twice. */
24:
25: /* Expansion of wild cards is done using RMS. */
26: typedef struct NAMBLK { struct NAM nam; /* VMS nam block structure */
27: char es[NAM$C_MAXRSS], /* Extended string */
28: rs[NAM$C_MAXRSS]; /* Resultant string */
29: };
30:
31: #define ErrorExit 2
32:
33: /* Allow the user to override _N_FARGS or _E_FLAG if they wish. */
34: #ifndef _N_FARGS
35: #define _N_FARGS 0
36: #endif
37: #ifndef _E_FLAG
38: #define _E_FLAG 2
39: #endif
40: /*
41: Since the following will possibly be included in a single module, try
42: hard to avoid name conflicts. (Just being static doesn't cut it if
43: compiled in the same module.)
44: */
45: #define redirect _r_edirect
46: #define filearg _f_ilearg
47: #define expand _e_xpand
48: #define wild_found _w_ild_found
49: #define wild_expand _w_ild_expand
50:
51: main(argc, argv, envp)
52: int argc;
53: char *argv[], *envp[];
54: {
55: char **expand();
56:
57: redirect (&argc, argv, _N_FARGS);
58: argv = expand (&argc, argv, _E_FLAG);
59:
60: /* Make the user's main entry point this routine's entry point. */
61: #define main _user_main
62: _user_main (argc, argv, envp);
63: }
64:
65: /*
66: * redirect(&argc,argv,nfargs) - redirect standard I/O
67: * int *argc number of command arguments (from call to main)
68: * char *argv[] command argument list (from call to main)
69: * int nfargs number of filename arguments to process
70: *
71: * argc and argv will be adjusted by redirect.
72: *
73: * redirect processes a program's command argument list and handles redirection
74: * of stdin, and stdout. Any arguments which redirect I/O are removed from the
75: * argument list, and argc is adjusted accordingly. redirect would typically be
76: * called as the first statement in the main program.
77: *
78: * Files are redirected based on syntax or position of command arguments.
79: * Arguments of the following forms always redirect a file:
80: *
81: * <file redirects standard input to read the given file
82: * >file redirects standard output to write to the given file
83: * >>file redirects standard output to append to the given file
84: *
85: * It is often useful to allow alternate input and output files as the
86: * first two command arguments without requiring the <file and >file
87: * syntax. If the nfargs argument to redirect is 2 or more then the
88: * first two command arguments, if supplied, will be interpreted in this
89: * manner: the first argument replaces stdin and the second stdout.
90: * A filename of "-" may be specified to occupy a position without
91: * performing any redirection.
92: *
93: * If nfargs is 1, only the first argument will be considered and will
94: * replace standard input if given. Any arguments processed by setting
95: * nfargs > 0 will be removed from the argument list, and again argc will
96: * be adjusted. Positional redirection follows syntax-specified
97: * redirection and therefore overrides it.
98: *
99: */
100:
101:
102: redirect(argc,argv,nfargs)
103: int *argc, nfargs;
104: char *argv[];
105: {
106: int i;
107:
108: i = 1;
109: while (i < *argc) { /* for every command argument... */
110: switch (argv[i][0]) { /* check first character */
111: case '<': /* <file redirects stdin */
112: filearg(argc,argv,i,1,stdin,"r");
113: break;
114: case '>': /* >file or >>file redirects stdout */
115: if (argv[i][1] == '>')
116: filearg(argc,argv,i,2,stdout,"a");
117: else
118: filearg(argc,argv,i,1,stdout,"w");
119: break;
120: default: /* not recognized, go on to next arg */
121: i++;
122: }
123: }
124: if (nfargs >= 1 && *argc > 1) /* if positional redirection & 1 arg */
125: filearg(argc,argv,1,0,stdin,"r"); /* then redirect stdin */
126: if (nfargs >= 2 && *argc > 1) /* likewise for 2nd arg if wanted */
127: filearg(argc,argv,1,0,stdout,"w");/* redirect stdout */
128: }
129:
130:
131:
132: /* filearg(&argc,argv,n,i,fp,mode) - redirect and remove file argument
133: * int *argc number of command arguments (from call to main)
134: * char *argv[] command argument list (from call to main)
135: * int n argv entry to use as file name and then delete
136: * int i first character of file name to use (skip '<' etc.)
137: * FILE *fp file pointer for file to reopen (typically stdin etc.)
138: * char mode[] file access mode (see freopen spec)
139: */
140:
141: filearg(argc,argv,n,i,fp,mode)
142: int *argc, n, i;
143: char *argv[], mode[];
144: FILE *fp;
145: {
146: if (strcmp(argv[n]+i,"-")) /* alter file if arg not "-" */
147: fp = freopen(argv[n]+i,mode,fp);
148: if (fp == NULL) { /* abort on error */
149: fprintf(stderr,"%%can't open %s",argv[n]+i);
150: exit(ErrorExit);
151: }
152: for ( ; n < *argc; n++) /* move down following arguments */
153: argv[n] = argv[n+1];
154: *argc = *argc - 1; /* decrement argument count */
155: }
156:
157: /* EXPAND code. */
158:
159: /* Global prototype. */
160: char **expand (int *argc, const char *argv[], const int flag);
161: /*-
162: ``expand()'' is a routine to expand wild-cards to file specifications.
163: This routine is often used in conjunction with ``redirect()'' to provide
164: both wild card expansion and standard file redirection prior to doing
165: any real work in a 'C' program.
166:
167: Normal usage is to include the following line prior to using argc or
168: argv in main():
169:
170: argv = expand (&argc, argv, 0);
171:
172: ``argc'' will be adjusted by ``expand()'', the return value from expand
173: will replace ``argv''.
174:
175: ``expand()'' processes a program's command argument list and expands any
176: wild cards into zero or more argv entries. Only arguments that posses VMS
177: wild-cards are expanded. Wild cards searched for are ``*'', ``%'',
178: ``...]'', and ``[-''. If the wild-card is found inside a single or double
179: quote ("*" or '%') then they are not counted as wild-cards. Be aware that
180: the expansion of a VMS wild card will match all VMS files, including
181: directory files (".DIR;1").
182:
183: NOTE: The use of quotes in VMS requires thinking about how the CLI expands
184: things before handing the argument line over to your program. Do not
185: expect "*" to avoid expansion, use """*""" instead. Likewise, expression
186: substitution precludes the use of (') to quote wild cards:
187: $ A := HELLO
188: $ ECHO 'a' ! 'C' program that calls ``expand()''
189: hello
190: The easiest way to escape a wild-card may be "'*'". The point is that
191: ``expand()'' will only recognize quotes passed into main().
192:
193: ``expand()'' references the VMS runtime routines, you will need to
194: link with the 'C' RTL whenever expand is used.
195:
196: Parameters:
197:
198: argc: Pointer to the number of command arguments (from main),
199: the contents of this parameter are modified.
200:
201: argv: Pointer to the initial command argument list (from main),
202: the contents are copied into a new array which is returned
203: from this routine.
204:
205: flag: Flag indicating how to expand wild-cards:
206: 0 - Complete file name expansion
207: 1 - only file name (no directory or version).
208: 2 - directory info and file name (no version).
209: 3 - file name and version info (no directory).
210: -*/
211:
212: /* Local prototypes. */
213: int wild_found (char *string);
214: char **wild_expand (const char *string, char **argv, int *argc,
215: int extra, int flag);
216: /*
217: General note: removing the prototyping and const keywords should
218: allow this code to compile with VMS 'C' compilers prior to version
219: 2.3-024.
220: */
221:
222:
223: char **expand (int *argc, char *argv[], int flag)
224: /*
225: Routine to expand all the arguments from main(argc,argv). The
226: return value is a pointer to a new (expanded) argv array.
227:
228: Parameters:
229:
230: argc: Pointer to the number of command arguments (from main),
231: the contents of this parameter are modified.
232:
233: argv: Pointer to the initial command argument list (from main),
234: the contents are copied into a new array which is returned
235: from this routine.
236:
237: flag: Flag indicating how to expand wild-card:
238: 0 - Complete file name expansion
239: 1 - only file name (no directory or version).
240: 2 - directory info and file name (no version).
241: 3 - file name and version info (no directory).
242: */
243: {
244: int i, nargc;
245: char **nargv, **wild_expand();
246: char *start, *end;
247:
248: /* Get an initial amount of memory for the master nargv array. */
249: if ((nargv = (char **)malloc ((*argc+1) * sizeof (char *))) == NULL) {
250: fprintf (stderr, "Not enough memory to expand argument list\n");
251: exit (ErrorExit);
252: }
253:
254: /*
255: Fix the command string so that it only has the name and not the path of
256: the function (more in line with what unix reports with argv[0]
257: */
258: start = argv[0];
259: end = argv[0] + strlen (argv[0]);
260: while (start < end) {
261: /* Scan from the back for the first '.' and replace it with a '\0' */
262: if (*end == '.') *end = '\0';
263: /* And trim off path if it is found. */
264: if (*end == ']') {
265: end++;
266: break;
267: }
268: --end;
269: }
270: nargv[0] = end;
271:
272: /* Copy each argument, expanding those that have wild characters. */
273: for (nargc = i = 1; i < *argc; i++) {
274: if (wild_found(argv[i]))
275: nargv = wild_expand(argv[i], nargv, &nargc, *argc-i, flag);
276: else
277: nargv[nargc++] = argv[i];
278: }
279: *argc = nargc;
280: nargv[nargc] = NULL; /* realloc always 0 fills, but... */
281:
282: return nargv;
283: }
284:
285:
286: static int wild_found (char *string)
287: /*
288: Routine to search the given string for a VMS wild-card pattern.
289: Returns 1 if "*", "%", "[-", or "...]" is found. (This may not
290: be all VMS wild-cards but it is enough for now--anyone that wants
291: to recognize others can change this code.)
292:
293: Parameter:
294:
295: string: '\0' terminated character array.
296: */
297: {
298: int state = 0;
299:
300: /*
301: State of 0 is "rest" state. State 1 on our way to [-, states 2-4
302: on our way to ...], negative states indicate the two quotes (' -10,
303: " -1).
304: */
305: for ( ;*string; string++) {
306: switch (*string) {
307: case '*':
308: case '%':
309: if (state >= 0)
310: return 1; /* Unquoted % or * found. */
311: break;
312: case '[':
313: if (state >= 0)
314: state = 1;
315: break;
316: case ']':
317: if (state == 4)
318: return 1; /* Unquoted ...] found. */
319: else if (state >= 0)
320: state = 0;
321: break;
322: case '-':
323: if (state == 1)
324: return 1; /* Unquoted [- found. */
325: else if (state >= 0)
326: state = 0;
327: break;
328: case '.':
329: if (state == 1 || state == 0)
330: state = 2; /* First '.' */
331: else if (state > 1 && state < 5)
332: state++; /* ... == states 2, 3, 4 */
333: else if (state >= 0)
334: state = 0;
335: break;
336: case '\'':
337: if (state <= -10)
338: state += 10; /* One ', possibly one " also */
339: else if (state < 0)
340: state -= 10; /* 0 ', possibly one " */
341: else
342: state = -10; /* No ' or " prior to this ' */
343: break;
344: case '"':
345: if (state == -11)
346: state = -10; /* Both " and ' prior to this. */
347: else if (state == -10)
348: state = -11; /* A ' prior to this. */
349: else if (state == -1)
350: state = 0; /* A " prior to this. */
351: else
352: state = -1; /* No ' or " prior to this " */
353: break;
354: }
355: }
356: return 0;
357: }
358:
359:
360: static char **wild_expand (const char *wild, char **argv,
361: int *argc, int extra, int flag)
362: /*
363: Routine to expand wild into new arguments appended to the end
364: of argv[*argc]. This routine must realloc in order to make room
365: for the individual arguments and malloc for enough space for each
366: of the arguments. The return value is a new **argv.
367:
368: Parameters:
369:
370: wild: '\0' terminated string that needs to be expanded.
371:
372: argv: initial starting address of the argv array.
373:
374: argc: pointer to an integer that tells the current end of the
375: argument list.
376:
377: extra: The number of extra pointers that the returned argv
378: must have available for future assignments.
379:
380: flag: Flag indicating how to expand wild-card:
381: 0 - Complete file name expansion
382: 1 - only file name (no directory or version).
383: 2 - directory info and file name (no version)
384: 3 - file name and version info (no directory).
385: */
386: {
387: int more_to_go = 1, err, length, status, len_wild;
388: char *namptr; /* , *strncpy(); Picky, but bothers other main programs */
389: struct FAB fab_blk;
390: struct NAMBLK nam_blk;
391:
392: len_wild = strlen(wild);
393:
394: /* Initialize all the fab and nam fields needed for parse and search */
395:
396: fab_blk = cc$rms_fab; /* Initialize FAB structure */
397:
398: nam_blk.nam = cc$rms_nam; /* Initialize NAM structure */
399: fab_blk.fab$l_dna = ".*"; /* Default file specif. */
400: fab_blk.fab$b_dns = 2; /* Length of default spec. */
401: fab_blk.fab$l_nam = &nam_blk.nam; /* Set address of NAM in FAB*/
402: nam_blk.nam.nam$b_ess = NAM$C_MAXRSS; /* Set extended string size*/
403: nam_blk.nam.nam$l_esa = &nam_blk.es; /* and address */
404: nam_blk.nam.nam$b_rss = NAM$C_MAXRSS; /* Set resultant string size*/
405: nam_blk.nam.nam$l_rsa = &nam_blk.rs; /* and address */
406: nam_blk.nam.nam$l_rlf = NULL; /* No related file address */
407:
408: fab_blk.fab$l_fna = wild; /* Address of file name string */
409: fab_blk.fab$b_fns = len_wild; /* Length of file name string */
410:
411: /* Prepare to enter the search loop, parse fab. */
412: err = SYS$PARSE (&fab_blk);
413:
414: /* Catch the directory not found error and return no files found. */
415: if (err != RMS$_NORMAL)
416: exit(err);
417:
418: while (more_to_go) {
419: err = SYS$SEARCH (&fab_blk);
420: if (err == RMS$_NMF || err == RMS$_FNF)
421: more_to_go = 0; /* Done, no more files found */
422: else if (err != RMS$_NORMAL)
423: exit (err);
424: else {
425: /* Count that we now have this many arguments. */
426: (*argc)++;
427:
428: /* Make sure there is room for a new pointer. */
429: if ((argv = realloc (argv, (*argc + extra)*sizeof(char *))) == NULL) {
430: fprintf (stderr, "Not enough memory to expand argument list\n");
431: exit(ErrorExit);
432: }
433:
434: /* Move the right name into the list. */
435: switch (flag) {
436: case 0: /* Complete file name */
437: length = nam_blk.nam.nam$b_rsl;
438: namptr = &nam_blk.rs;
439: break;
440: case 1: /* File name only (no directory or version). */
441: length = nam_blk.nam.nam$b_name + nam_blk.nam.nam$b_type;
442: namptr = nam_blk.nam.nam$l_name;
443: break;
444: case 2: /* directory and file name (no version) */
445: length = nam_blk.nam.nam$b_rsl - nam_blk.nam.nam$b_ver;
446: namptr = &nam_blk.rs;
447: break;
448: case 3: /* File name and version (no directory). */
449: length = nam_blk.nam.nam$b_name +
450: nam_blk.nam.nam$b_type +
451: nam_blk.nam.nam$b_ver;
452: namptr = nam_blk.nam.nam$l_name;
453: break;
454: default:
455: fprintf (stderr, "illegal flag used in VMS expand call\n");
456: exit (ErrorExit);
457: }
458: /* Copy the requested string into the argument array. */
459: if ((argv[*argc-1] = malloc (length+1)) == NULL) {
460: fprintf (stderr, "Not enough memory to expand argument list\n");
461: exit (ErrorExit);
462: }
463: (void )strncpy (argv[*argc-1], namptr, length);
464: argv[*argc-1][length] = '\0';
465: }
466: }
467: return (argv);
468: }
469:
470: /* Remove all the defines that might affect the user's code. */
471:
472: #undef redirect
473: #undef filearg
474: #undef expand
475: #undef wild_found
476: #undef wild_expand
477:
478: #ifdef __TST_ECHO /* Example code using expand(). */
479:
480: # ifndef __FILE
481: #include stdio
482: #endif
483:
484: main(argc, argv)
485: int argc;
486: char *argv[];
487: /*
488: This main program allows you to run experiments with ``expand()''.
489: Try $ echo *.*, $ echo -f1 [-...]*.*, $ echo -f[0-3] *.*.
490: Questions about using "%", "\", etc. may be answered by testing
491: with this version of echo.
492:
493: To use this, of course, you need to link directly with expand--
494: avoiding the substitution of main with _user_main above.
495: */
496: {
497: int i, flag=0;
498: char **expand();
499:
500: for(i=1; i<argc; i++)
501: printf("%s %c", argv[i], (i<argc-1) ? ' ':'\n');
502:
503: if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'f')
504: flag = atoi (&argv[1][2]);
505:
506: argv = expand (&argc, argv, flag);
507:
508: printf ("\n\n");
509: for(i=1; i<argc; i++)
510: printf("%s %c", argv[i], flag%2 == 0 ? '\n' : i%4 == 0 ? '\n':'\t');
511:
512: }
513: #endif /* __TST_ECHO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.