![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to amiga__main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [PGP] / pgp / src|
Return to amiga__main.c CVS log | Up to [PGP] / pgp / src |
1.1 root 1: /*
2: $VER: RKNOP's __main() 1.2 (06.02.95)
3:
4: Replacement AmigaDOS __main() for SAS/C 6.51.
5:
6: As with the standard __main(), this parses the input command line into the
7: argv array. However, here, the number of arguments is unlimited;
8: additionally, one may specify on the command line a list of arguments in
9: a file using the construction "@filename" (without quotes). The named file
10: will be read and all of the whitespace separated arguments therein will be
11: inserted to the argv array at that point. Since the string parser is written
12: recursively, embedded files may be nested; that is, within one filename
13: referenced on the command line with @, there may be another filename
14: referenced with @. Memory and stack space is the only limit as to how far
15: the nesting may go.
16:
17: Version 1.2 -- this version supports stderr redirection, similar to unix, by
18: specifying &filename (or & filename or &"file name" or & "file name") on the
19: command line. stderr is redirected by opening first calling Close() on what
20: is currently in __ufbs[2].ufbfh (hopefully this simulates the SAS stdio
21: destructor), and then Open()ing the file __ufbs[2].ufbfh with the specified
22: filename.
23:
24: Inspiration by Peter Simons. Rewritten from scratch by Robert Knop using no
25: SAS code so that this file could be freely distributed with PGP 2.6
26: source code.
27:
28: [email protected]
29: [email protected]
30: R.KNOP1 on GEnie
31: */
32:
33: #include <stdlib.h>
34: #include <stdio.h>
35: #include <string.h>
36: #include <ios1.h>
37: #include <dos/dos.h>
38: #include <exec/lists.h>
39: #include <exec/memory.h>
40: #include <exec/nodes.h>
41: #include <libraries/dos.h>
42: #include <libraries/dosextens.h>
43: #include <workbench/startup.h>
44:
45: #include <proto/dos.h>
46: #include <proto/exec.h>
47:
48: #define isspace(c) (((c)==' ')||((c)=='\t')||((c)=='\n'))
49:
50: extern struct WBStartup *_WBenchMsg;
51:
52: int main(int,void *);
53: int __regargs CountArgs(struct MinList *,struct ArgNode *);
54: void __regargs AddArgs(struct ArgNode **,char ***);
55:
56: struct ArgNode {
57: struct MinNode n;
58: int length;
59: char *d;
60: };
61:
62: void __stdargs __main(char *inline)
63: { struct ArgNode n,*cur;
64: struct MinList ArgStrings;
65: int argc,rval;
66: char **argv,**pargv;
67:
68: NewList((struct List *)&ArgStrings);
69: n.d=inline;
70: AddTail((struct List *)&ArgStrings,(struct Node *)&n);
71:
72: if (inline && (argc=CountArgs(&ArgStrings,&n)))
73: { if (!(argv=(char **)calloc(argc+1,sizeof(char *))))
74: /* +1 is for one null element at the end of argv */
75: exit(20);
76: cur=&n;
77: pargv=argv;
78: AddArgs(&cur,&pargv);
79: }
80: else argv=(char **)_WBenchMsg; /* Workbench startup */
81:
82: rval=main(argc,argv);
83:
84: /* Don't worry about cleanup -- we used only calloc & malloc */
85: /* (It's safer this way, so that if the program goes directly to exit()
86: we don't have to worry about missed cleanup.) */
87:
88: exit(rval);
89: }
90:
91: /**********************************************************************/
92: /* CountArgs() -- a recursive function that counts the number of */
93: /* arguments in the string in node.d. If, while */
94: /* counting, it comes across an argument of the form */
95: /* "@filename", it creates a new node on the tail of */
96: /* list, reads the data from the named file */
97: /* into this new node's data, and recursively calls */
98: /* itself to count the arguments in the new read string*/
99: /**********************************************************************/
100:
101: int __regargs CountArgs(struct MinList *list,struct ArgNode *node)
102: { int argc;
103: struct ArgNode *n;
104: char *line,*fstart,fendbuffer;
105: BPTR ifp; /* Only 1 file will be open at a time */
106: static struct FileInfoBlock fib; /* static safe for recursion */
107:
108: argc=0;
109: line=node->d;
110: while (1)
111: { while (isspace(*line)) line++; /* Skip leading whitespace */
112:
113: if (*line=='\0') break;
114:
115: else if (*line=='&') /* Skip a stderr redirect */
116: { ++line;
117: while (isspace(*line)) ++line;
118: if (*line=='"')
119: { line++;
120: while (*line!='"' && *line!='\0') line++;
121: if (*line=='"') line++;
122: }
123: else
124: { while (!isspace(*line))
125: { if (*line=='\0') break;
126: ++line;
127: }
128: }
129: }
130:
131: else if (*line=='@') /* Embedded file */
132: { fstart=++line;
133: if (*line=='"')
134: { fstart++; line++;
135: while (*line!='"')
136: if (*(++line)=='\0') break; /* Errorish? */
137: fendbuffer=*line;
138: *line='\0'; /* Temporarily 0-term so we can use as a filename */
139: }
140: else
141: { while (!isspace(*line))
142: if (*(++line)=='\0') break; /* Error? */
143: fendbuffer=*line;
144: *line='\0'; /* Temp 0-term for filename */
145: }
146: if (!(ifp=Open(fstart,MODE_OLDFILE)))
147: fprintf(stderr,"Couldn't open file \"%s\"\n",fstart);
148: else
149: { ExamineFH(ifp,&fib);
150: n=(struct ArgNode *)calloc(sizeof(struct ArgNode),1);
151: /* CHECK ERRORS!!!!!!!!!!! */
152: AddTail((struct List *)list,(struct Node *)n);
153: if (fib.fib_Size)
154: { n->d=calloc((n->length=fib.fib_Size+1),1);
155: Read(ifp,n->d,fib.fib_Size);
156: n->d[fib.fib_Size]='\0'; /* Make sure null terminated */
157: }
158: Close(ifp);
159: if (n->d) argc+=CountArgs(list,n); /* Recurse */
160: }
161: *line=fendbuffer; /* Restore char replaced with '\0' */
162: if (*line=='"') ++line; /* Increment line past quote */
163: } /* End of embedded file handling */
164:
165: else if (*line=='"')
166: { ++line;
167: while (*line!='"')
168: if (*(++line)=='\0') break;
169: argc++;
170: if (*line='"') ++line;
171: }
172:
173: else
174: { while (!isspace(*line))
175: if (*(++line)=='\0') break;
176: argc++;
177: }
178:
179: } /* End of infinite loop */
180:
181: return(argc); /* Also returns any nodes added to list from embed files */
182: }
183:
184: /**********************************************************************/
185: /* AddArgs() -- put each of the arguments in the node into the array */
186: /* argv. Recurse if necessary */
187: /**********************************************************************/
188:
189: void __regargs AddArgs(struct ArgNode **node,char ***argv)
190: { char *line,*stderrfile;
191:
192: line=(*node)->d;
193: (*node)=(struct ArgNode*)(*node)->n.mln_Succ;
194: while (1)
195: { while (isspace(*line)) line++; /* Skip leading whitespace */
196:
197: if (*line=='\0') break; /* Finished */
198:
199: else if (*line=='&') /* stderr redirect */
200: { ++line;
201: while (isspace(*line)) ++line;
202: if (*line=='"')
203: { stderrfile=++line;
204: while (*line!='"' && *line!='\0') line++;
205: if (*line=='"') { *line='\0'; line++; }
206: }
207: else
208: { stderrfile=line;
209: while (!isspace(*line))
210: { if (*line=='\0') break;
211: line++;
212: }
213: if (*line!='\0') { *line='\0'; line++; }
214: }
215: Close(__ufbs[2].ufbfh);
216: if ((__ufbs[2].ufbfh=Open(stderrfile,MODE_NEWFILE))==NULL)
217: __ufbs[2].ufbfh=Open("NIL:",MODE_OLDFILE);
218: }
219:
220: else if (*line=='@') /* Embedded file -- skip past filename */
221: { ++line;
222: if (*line=='"')
223: { while (*line!='"')
224: if (*(++line)=='\0') break;
225: }
226: else
227: { while (!isspace(*line))
228: if (*(++line)=='\0') break;
229: }
230: AddArgs(node,argv); /* Add the arguments from whatever node */
231: if (*line!='\0') ++line;
232: }
233:
234: else if (*line=='"')
235: { (*argv)[0]=++line;
236: while (*line!='"')
237: if (*(++line)=='\0') break;
238: if (*line!='\0')
239: { *line='\0'; /* Null terminate this argument */
240: ++line;
241: }
242: (*argv)++;
243: }
244:
245: else
246: { (*argv)[0]=line;
247: while (!isspace(*line))
248: if (*(++line)=='\0') break;
249: if (*line!='\0')
250: { *line='\0'; /* Null terminate this argument */
251: ++line;
252: }
253: (*argv)++;
254: }
255: } /* End of infinite loop */
256: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.