source: obsolete/trunk/BUTE/Ogre/PreComputingRuns/header.c @ 126

Revision 126, 6.7 KB checked in by barsi, 19 years ago (diff)

Added a folder remotely

Line 
1#ifndef lint
2static const char       RCSid[] = "$Id: header.c,v 2.13 2003/03/10 17:13:29 greg Exp $";
3#endif
4/*
5 *  header.c - routines for reading and writing information headers.
6 *
7 *  Externals declared in resolu.h
8 *
9 *  newheader(t,fp)     start new information header identified by string t
10 *  isheadid(s)         returns true if s is a header id line
11 *  headidval(r,s)      copy header identifier value in s to r
12 *  dateval(t,s)        get capture date value
13 *  isdate(s)           returns true if s is a date line
14 *  fputdate(t,fp)      put out the given capture date and time
15 *  fputnow(fp)         put out the current date and time
16 *  printargs(ac,av,fp) print an argument list to fp, followed by '\n'
17 *  isformat(s)         returns true if s is of the form "FORMAT=*"
18 *  formatval(r,s)      copy the format value in s to r
19 *  fputformat(s,fp)    write "FORMAT=%s" to fp
20 *  getheader(fp,f,p)   read header from fp, calling f(s,p) on each line
21 *  globmatch(pat, str) check for glob match of str against pat
22 *  checkheader(i,p,o)  check header format from i against p and copy to o
23 *
24 *  To copy header from input to output, use getheader(fin, fputs, fout)
25 */
26
27//#include "copyright.h"
28
29#include  <stdio.h>
30#include  <string.h>
31#include  <time.h>
32#include  <ctype.h>
33
34#define  MAXLINE        512
35
36char  HDRSTR[] = "#?";          /* information header magic number */
37
38char  FMTSTR[] = "FORMAT=";     /* format identifier */
39
40char  TMSTR[] = "CAPDATE=";     /* capture date identifier */
41
42static int mycheck();
43
44
45void
46newheader(s, fp)                /* identifying line of information header */
47char  *s;
48register FILE  *fp;
49{
50        fputs(HDRSTR, fp);
51        fputs(s, fp);
52        putc('\n', fp);
53}
54
55
56int
57headidval(r,s)                  /* get header id (return true if is id) */
58register char  *r, *s;
59{
60        register char  *cp = HDRSTR;
61
62        while (*cp) if (*cp++ != *s++) return(0);
63        if (r == NULL) return(1);
64        while (*s && !isspace(*s)) *r++ = *s++;
65        *r = '\0';
66        return(1);
67}
68
69
70int
71isheadid(s)                     /* check to see if line is header id */
72char  *s;
73{
74        return(headidval(NULL, s));
75}
76
77
78int
79dateval(tloc, s)                /* get capture date value */
80time_t  *tloc;
81char    *s;
82{
83        struct tm       tms;
84        register char  *cp = TMSTR;
85
86        while (*cp) if (*cp++ != *s++) return(0);
87        while (isspace(*s)) s++;
88        if (!*s) return(0);
89        if (sscanf(s, "%d:%d:%d %d:%d:%d",
90                        &tms.tm_year, &tms.tm_mon, &tms.tm_mday,
91                        &tms.tm_hour, &tms.tm_min, &tms.tm_sec) != 6)
92                return(0);
93        if (tloc == NULL)
94                return(1);
95        tms.tm_mon--;
96        tms.tm_year -= 1900;
97        tms.tm_isdst = -1;      /* ask mktime() to figure out DST */
98        *tloc = mktime(&tms);
99        return(1);
100}
101
102
103int
104isdate(s)                       /* is the given line a capture date? */
105char *s;
106{
107        return(dateval(NULL, s));
108}
109
110
111void
112fputdate(tv, fp)                /* write out the given time value */
113time_t  tv;
114FILE    *fp;
115{
116        struct tm       *tm = localtime(&tv);
117        if (tm == NULL)
118                return;
119        fprintf(fp, "%s %04d:%02d:%02d %02d:%02d:%02d\n", TMSTR,
120                        tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
121                        tm->tm_hour, tm->tm_min, tm->tm_sec);
122}
123
124
125void
126fputnow(fp)                     /* write out the current time */
127FILE    *fp;
128{
129        time_t  tv;
130        time(&tv);
131        fputdate(tv, fp);
132}
133
134
135void
136printargs(ac, av, fp)           /* print arguments to a file */
137int  ac;
138char  **av;
139FILE  *fp;
140{
141        int  quote;
142
143        while (ac-- > 0) {
144//WARN HACK             fputword(*av++, fp);
145                fputc(ac ? ' ' : '\n', fp);
146        }
147}
148
149
150int
151formatval(r, s)                 /* get format value (return true if format) */
152register char  *r;
153register char  *s;
154{
155        register char  *cp = FMTSTR;
156
157        while (*cp) if (*cp++ != *s++) return(0);
158        while (isspace(*s)) s++;
159        if (!*s) return(0);
160        if (r == NULL) return(1);
161        do
162                *r++ = *s++;
163        while(*s && !isspace(*s));
164        *r = '\0';
165        return(1);
166}
167
168
169int
170isformat(s)                     /* is line a format line? */
171char  *s;
172{
173        return(formatval(NULL, s));
174}
175
176
177void
178fputformat(s, fp)               /* put out a format value */
179char  *s;
180FILE  *fp;
181{
182        fputs(FMTSTR, fp);
183        fputs(s, fp);
184        putc('\n', fp);
185}
186
187
188int
189getheader(fp, f, p)             /* get header from file */
190FILE  *fp;
191int  (*f)();
192char  *p;
193{
194        char  buf[MAXLINE];
195
196        for ( ; ; ) {
197                buf[MAXLINE-2] = '\n';
198                if (fgets(buf, MAXLINE, fp) == NULL)
199                        return(-1);
200                if (buf[0] == '\n')
201                        return(0);
202#ifdef MSDOS
203                if (buf[0] == '\r' && buf[1] == '\n')
204                        return(0);
205#endif
206                if (buf[MAXLINE-2] != '\n') {
207                        ungetc(buf[MAXLINE-2], fp);     /* prevent false end */
208                        buf[MAXLINE-2] = '\0';
209                }
210                if (f != NULL && (*f)(buf, p) < 0)
211                        return(-1);
212        }
213}
214
215
216struct check {
217        FILE    *fp;
218        char    fs[64];
219};
220
221
222static int
223mycheck(s, cp)                  /* check a header line for format info. */
224char  *s;
225register struct check  *cp;
226{
227        if (!formatval(cp->fs, s) && cp->fp != NULL)
228                fputs(s, cp->fp);
229        return(0);
230}
231
232
233int
234globmatch(p, s)                 /* check for match of s against pattern p */
235register char   *p, *s;
236{
237        int     setmatch;
238
239        do {
240                switch (*p) {
241                case '?':                       /* match any character */
242                        if (!*s++)
243                                return(0);
244                        break;
245                case '*':                       /* match any string */
246                        while (p[1] == '*') p++;
247                        do
248                                if ( (p[1]=='?' || p[1]==*s) &&
249                                                globmatch(p+1,s) )
250                                        return(1);
251                        while (*s++);
252                        return(0);
253                case '[':                       /* character set */
254                        setmatch = *s == *++p;
255                        if (!*p)
256                                return(0);
257                        while (*++p != ']') {
258                                if (!*p)
259                                        return(0);
260                                if (*p == '-') {
261                                        setmatch += p[-1] <= *s && *s <= p[1];
262                                        if (!*++p)
263                                                break;
264                                } else
265                                        setmatch += *p == *s;
266                        }
267                        if (!setmatch)
268                                return(0);
269                        s++;
270                        break;
271                case '\\':                      /* literal next */
272                        p++;
273                /* fall through */
274                default:                        /* normal character */
275                        if (*p != *s)
276                                return(0);
277                        s++;
278                        break;
279                }
280        } while (*p++);
281        return(1);
282}
283
284
285/*
286 * Checkheader(fin,fmt,fout) returns a value of 1 if the input format
287 * matches the specification in fmt, 0 if no input format was found,
288 * and -1 if the input format does not match or there is an
289 * error reading the header.  If fmt is empty, then -1 is returned
290 * if any input format is found (or there is an error), and 0 otherwise.
291 * If fmt contains any '*' or '?' characters, then checkheader
292 * does wildcard expansion and copies a matching result into fmt.
293 * Be sure that fmt is big enough to hold the match in such cases,
294 * and that it is not a static, read-only string!
295 * The input header (minus any format lines) is copied to fout
296 * if fout is not NULL.
297 */
298
299int
300checkheader(fin, fmt, fout)
301FILE  *fin;
302char  *fmt;
303FILE  *fout;
304{
305        struct check    cdat;
306        register char   *cp;
307
308        cdat.fp = fout;
309        cdat.fs[0] = '\0';
310        if (getheader(fin, mycheck, &cdat) < 0)
311                return(-1);
312        if (!cdat.fs[0])
313                return(0);
314        for (cp = fmt; *cp; cp++)               /* check for globbing */
315                if (*cp == '?' | *cp == '*')
316                        if (globmatch(fmt, cdat.fs)) {
317                                strcpy(fmt, cdat.fs);
318                                return(1);
319                        } else
320                                return(-1);
321        return(strcmp(fmt, cdat.fs) ? -1 : 1);  /* literal match */
322}
Note: See TracBrowser for help on using the repository browser.