/[MITgcm]/MITgcm/tools/cyrus-imapd-makedepend/ifparser.c
ViewVC logotype

Annotation of /MITgcm/tools/cyrus-imapd-makedepend/ifparser.c

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph


Revision 1.1 - (hide annotations) (download)
Wed Feb 25 18:19:54 2004 UTC (17 years, 2 months ago) by edhill
Branch: MAIN
CVS Tags: checkpoint64y, checkpoint64x, checkpoint58l_post, checkpoint64z, checkpoint57t_post, checkpoint64q, checkpoint64p, checkpoint64s, checkpoint64r, checkpoint64u, checkpoint64t, checkpoint64w, checkpoint64v, checkpoint64i, checkpoint64h, checkpoint64k, checkpoint64j, checkpoint64m, checkpoint64l, checkpoint64o, checkpoint64n, checkpoint64a, checkpoint57o_post, checkpoint64c, checkpoint64b, checkpoint64e, checkpoint64d, checkpoint64g, checkpoint64f, checkpoint52l_pre, checkpoint58e_post, mitgcm_mapl_00, checkpoint52n_post, checkpoint53d_post, checkpoint58u_post, checkpoint58w_post, checkpoint54a_pre, checkpoint57m_post, checkpoint55c_post, checkpoint54e_post, checkpoint57s_post, checkpoint54a_post, checkpoint63p, checkpoint63q, checkpoint63r, checkpoint63s, checkpoint63l, checkpoint63m, checkpoint63n, checkpoint63o, checkpoint63h, checkpoint63i, checkpoint63j, checkpoint63k, checkpoint63d, checkpoint63e, checkpoint63f, checkpoint63g, checkpoint53c_post, checkpoint63a, checkpoint63b, checkpoint63c, checkpoint57k_post, checkpoint55d_pre, checkpoint57d_post, checkpoint57g_post, checkpoint64, checkpoint65, checkpoint60, checkpoint61, checkpoint62, checkpoint63, checkpoint57b_post, checkpoint57c_pre, checkpoint58r_post, checkpoint55j_post, checkpoint56b_post, checkpoint57i_post, checkpoint57y_post, checkpoint57e_post, checkpoint66g, checkpoint66f, checkpoint66e, checkpoint66d, checkpoint66c, checkpoint66b, checkpoint66a, checkpoint66o, checkpoint66n, checkpoint66m, checkpoint66l, checkpoint66k, checkpoint66j, checkpoint66i, checkpoint66h, checkpoint52l_post, checkpoint55h_post, checkpoint58n_post, checkpoint53b_post, checkpoint58x_post, checkpoint57g_pre, checkpoint54b_post, checkpoint53b_pre, checkpoint55b_post, checkpoint58t_post, checkpoint58h_post, checkpoint65z, checkpoint65x, checkpoint65y, checkpoint54d_post, checkpoint65r, checkpoint65s, checkpoint65p, checkpoint65q, checkpoint65v, checkpoint65w, checkpoint65t, checkpoint65u, checkpoint65j, checkpoint65k, checkpoint65h, checkpoint65i, checkpoint65n, checkpoint65o, checkpoint65l, checkpoint65m, checkpoint65b, checkpoint65c, checkpoint65a, checkpoint65f, checkpoint65g, checkpoint65d, checkpoint65e, checkpoint56c_post, checkpoint52m_post, checkpoint57y_pre, checkpoint55, checkpoint53a_post, checkpoint57f_pre, checkpoint57a_post, checkpoint54, checkpoint58q_post, checkpoint54f_post, checkpoint57v_post, checkpoint59q, checkpoint59p, checkpoint55g_post, checkpoint59r, checkpoint58j_post, checkpoint59e, checkpoint59d, checkpoint59g, checkpoint59f, checkpoint59a, checkpoint55f_post, checkpoint59c, checkpoint59b, checkpoint59m, checkpoint59l, checkpoint59o, checkpoint59n, checkpoint59i, checkpoint59h, checkpoint59k, checkpoint59j, checkpoint57r_post, checkpoint59, checkpoint58, checkpoint57a_pre, checkpoint55i_post, checkpoint57, checkpoint56, checkpoint53, eckpoint57e_pre, checkpoint57h_done, checkpoint58f_post, checkpoint53g_post, checkpoint57x_post, checkpoint57n_post, checkpoint58d_post, checkpoint58c_post, checkpoint57w_post, checkpoint57p_post, checkpint57u_post, checkpoint57f_post, checkpoint58a_post, checkpoint58i_post, checkpoint57q_post, checkpoint58g_post, hrcube5, checkpoint58o_post, checkpoint57z_post, checkpoint62c, checkpoint62b, checkpoint62a, checkpoint62g, checkpoint62f, checkpoint62e, checkpoint62d, checkpoint62k, checkpoint62j, checkpoint62i, checkpoint62h, checkpoint62o, checkpoint62n, checkpoint62m, checkpoint62l, checkpoint62s, checkpoint62r, checkpoint62q, checkpoint62p, checkpoint62w, checkpoint62v, checkpoint62u, checkpoint62t, checkpoint57c_post, checkpoint62z, checkpoint62y, checkpoint62x, checkpoint58y_post, checkpoint55e_post, checkpoint58k_post, checkpoint58v_post, checkpoint53f_post, checkpoint55a_post, checkpoint53d_pre, checkpoint54c_post, checkpoint58s_post, checkpoint61f, checkpoint61g, checkpoint61d, checkpoint61e, checkpoint61b, checkpoint61c, checkpoint58p_post, checkpoint61a, checkpoint61n, checkpoint61o, checkpoint61l, checkpoint61m, checkpoint61j, checkpoint61k, checkpoint61h, checkpoint61i, checkpoint61v, checkpoint61w, checkpoint61t, checkpoint61u, checkpoint61r, checkpoint61s, checkpoint61p, checkpoint61q, checkpoint57j_post, checkpoint61z, checkpoint61x, checkpoint61y, checkpoint58b_post, checkpoint57h_pre, checkpoint58m_post, checkpoint57l_post, checkpoint57h_post, checkpoint56a_post, checkpoint55d_post, HEAD
File MIME type: text/plain
 o initial check-in of a better makedepend implementation for AJA

1 edhill 1.1 /*
2     * $XConsortium: ifparser.c,v 1.7 94/01/18 21:30:50 rws Exp $
3     * Copyright (c) 1998-2003 Carnegie Mellon University. All rights reserved.
4     *
5     * Redistribution and use in source and binary forms, with or without
6     * modification, are permitted provided that the following conditions
7     * are met:
8     *
9     * 1. Redistributions of source code must retain the above copyright
10     * notice, this list of conditions and the following disclaimer.
11     *
12     * 2. Redistributions in binary form must reproduce the above copyright
13     * notice, this list of conditions and the following disclaimer in
14     * the documentation and/or other materials provided with the
15     * distribution.
16     *
17     * 3. The name "Carnegie Mellon University" must not be used to
18     * endorse or promote products derived from this software without
19     * prior written permission. For permission or any other legal
20     * details, please contact
21     * Office of Technology Transfer
22     * Carnegie Mellon University
23     * 5000 Forbes Avenue
24     * Pittsburgh, PA 15213-3890
25     * (412) 268-4387, fax: (412) 268-7395
26     * tech-transfer@andrew.cmu.edu
27     *
28     * 4. Redistributions of any form whatsoever must retain the following
29     * acknowledgment:
30     * "This product includes software developed by Computing Services
31     * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
32     *
33     * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
34     * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
35     * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
36     * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
37     * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
38     * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
39     * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
40     *
41     *
42     * Copyright 1992 Network Computing Devices, Inc.
43     *
44     * Permission to use, copy, modify, and distribute this software and its
45     * documentation for any purpose and without fee is hereby granted, provided
46     * that the above copyright notice appear in all copies and that both that
47     * copyright notice and this permission notice appear in supporting
48     * documentation, and that the name of Network Computing Devices may not be
49     * used in advertising or publicity pertaining to distribution of the software
50     * without specific, written prior permission. Network Computing Devices makes
51     * no representations about the suitability of this software for any purpose.
52     * It is provided ``as is'' without express or implied warranty.
53     *
54     * NETWORK COMPUTING DEVICES DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
55     * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
56     * IN NO EVENT SHALL NETWORK COMPUTING DEVICES BE LIABLE FOR ANY SPECIAL,
57     * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
58     * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
59     * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
60     * PERFORMANCE OF THIS SOFTWARE.
61     *
62     * Author: Jim Fulton
63     * Network Computing Devices, Inc.
64     *
65     * Simple if statement processor
66     *
67     * This module can be used to evaluate string representations of C language
68     * if constructs. It accepts the following grammar:
69     *
70     * EXPRESSION := VALUE
71     * | VALUE BINOP EXPRESSION
72     *
73     * VALUE := '(' EXPRESSION ')'
74     * | '!' VALUE
75     * | '-' VALUE
76     * | 'defined' '(' variable ')'
77     * | 'defined' variable
78     * | # variable '(' variable-list ')'
79     * | variable
80     * | number
81     *
82     * BINOP := '*' | '/' | '%'
83     * | '+' | '-'
84     * | '<<' | '>>'
85     * | '<' | '>' | '<=' | '>='
86     * | '==' | '!='
87     * | '&' | '|'
88     * | '&&' | '||'
89     *
90     * The normal C order of precidence is supported.
91     *
92     *
93     * External Entry Points:
94     *
95     * ParseIfExpression parse a string for #if
96     */
97    
98     #include "ifparser.h"
99     #include <ctype.h>
100    
101     /****************************************************************************
102     Internal Macros and Utilities for Parser
103     ****************************************************************************/
104    
105     #define DO(val) if (!(val)) return NULL
106     #define CALLFUNC(ggg,fff) (*((ggg)->funcs.fff))
107     #define SKIPSPACE(ccc) while (isspace(*ccc)) ccc++
108     #define isvarfirstletter(ccc) (isalpha(ccc) || (ccc) == '_')
109    
110    
111     static const char *
112     parse_variable (g, cp, varp)
113     IfParser *g;
114     const char *cp;
115     const char **varp;
116     {
117     SKIPSPACE (cp);
118    
119     if (!isvarfirstletter (*cp))
120     return CALLFUNC(g, handle_error) (g, cp, "variable name");
121    
122     *varp = cp;
123     /* EMPTY */
124     for (cp++; isalnum(*cp) || *cp == '_'; cp++) ;
125     return cp;
126     }
127    
128    
129     static const char *
130     parse_number (g, cp, valp)
131     IfParser *g;
132     const char *cp;
133     int *valp;
134     {
135     SKIPSPACE (cp);
136    
137     if (!isdigit(*cp))
138     return CALLFUNC(g, handle_error) (g, cp, "number");
139    
140     #ifdef WIN32
141     *valp = strtol(cp, &cp, 0);
142     #else
143     *valp = atoi (cp);
144     /* EMPTY */
145     for (cp++; isdigit(*cp); cp++) ;
146     #endif
147     return cp;
148     }
149    
150    
151     static const char *
152     parse_value (g, cp, valp)
153     IfParser *g;
154     const char *cp;
155     int *valp;
156     {
157     const char *var;
158    
159     *valp = 0;
160    
161     SKIPSPACE (cp);
162     if (!*cp)
163     return cp;
164    
165     switch (*cp) {
166     case '(':
167     DO (cp = ParseIfExpression (g, cp + 1, valp));
168     SKIPSPACE (cp);
169     if (*cp != ')')
170     return CALLFUNC(g, handle_error) (g, cp, ")");
171    
172     return cp + 1; /* skip the right paren */
173    
174     case '!':
175     DO (cp = parse_value (g, cp + 1, valp));
176     *valp = !(*valp);
177     return cp;
178    
179     case '-':
180     DO (cp = parse_value (g, cp + 1, valp));
181     *valp = -(*valp);
182     return cp;
183    
184     case '#':
185     DO (cp = parse_variable (g, cp + 1, &var));
186     SKIPSPACE (cp);
187     if (*cp != '(')
188     return CALLFUNC(g, handle_error) (g, cp, "(");
189     do {
190     DO (cp = parse_variable (g, cp + 1, &var));
191     SKIPSPACE (cp);
192     } while (*cp && *cp != ')');
193     if (*cp != ')')
194     return CALLFUNC(g, handle_error) (g, cp, ")");
195     *valp = 1; /* XXX */
196     return cp + 1;
197    
198     case 'd':
199     if (strncmp (cp, "defined", 7) == 0 && !isalnum(cp[7])) {
200     int paren = 0;
201     cp += 7;
202     SKIPSPACE (cp);
203     if (*cp == '(') {
204     paren = 1;
205     cp++;
206     }
207     DO (cp = parse_variable (g, cp, &var));
208     SKIPSPACE (cp);
209     if (paren && *cp != ')')
210     return CALLFUNC(g, handle_error) (g, cp, ")");
211     *valp = (*(g->funcs.eval_defined)) (g, var, cp - var);
212     return cp + paren; /* skip the right paren */
213     }
214     /* fall out */
215     }
216    
217     if (isdigit(*cp)) {
218     DO (cp = parse_number (g, cp, valp));
219     } else if (!isvarfirstletter(*cp))
220     return CALLFUNC(g, handle_error) (g, cp, "variable or number");
221     else {
222     DO (cp = parse_variable (g, cp, &var));
223     *valp = (*(g->funcs.eval_variable)) (g, var, cp - var);
224     }
225    
226     return cp;
227     }
228    
229    
230    
231     static const char *
232     parse_product (g, cp, valp)
233     IfParser *g;
234     const char *cp;
235     int *valp;
236     {
237     int rightval;
238    
239     DO (cp = parse_value (g, cp, valp));
240     SKIPSPACE (cp);
241    
242     switch (*cp) {
243     case '*':
244     DO (cp = parse_product (g, cp + 1, &rightval));
245     *valp = (*valp * rightval);
246     break;
247    
248     case '/':
249     DO (cp = parse_product (g, cp + 1, &rightval));
250     *valp = (*valp / rightval);
251     break;
252    
253     case '%':
254     DO (cp = parse_product (g, cp + 1, &rightval));
255     *valp = (*valp % rightval);
256     break;
257     }
258     return cp;
259     }
260    
261    
262     static const char *
263     parse_sum (g, cp, valp)
264     IfParser *g;
265     const char *cp;
266     int *valp;
267     {
268     int rightval;
269    
270     DO (cp = parse_product (g, cp, valp));
271     SKIPSPACE (cp);
272    
273     switch (*cp) {
274     case '+':
275     DO (cp = parse_sum (g, cp + 1, &rightval));
276     *valp = (*valp + rightval);
277     break;
278    
279     case '-':
280     DO (cp = parse_sum (g, cp + 1, &rightval));
281     *valp = (*valp - rightval);
282     break;
283     }
284     return cp;
285     }
286    
287    
288     static const char *
289     parse_shift (g, cp, valp)
290     IfParser *g;
291     const char *cp;
292     int *valp;
293     {
294     int rightval;
295    
296     DO (cp = parse_sum (g, cp, valp));
297     SKIPSPACE (cp);
298    
299     switch (*cp) {
300     case '<':
301     if (cp[1] == '<') {
302     DO (cp = parse_shift (g, cp + 2, &rightval));
303     *valp = (*valp << rightval);
304     }
305     break;
306    
307     case '>':
308     if (cp[1] == '>') {
309     DO (cp = parse_shift (g, cp + 2, &rightval));
310     *valp = (*valp >> rightval);
311     }
312     break;
313     }
314     return cp;
315     }
316    
317    
318     static const char *
319     parse_inequality (g, cp, valp)
320     IfParser *g;
321     const char *cp;
322     int *valp;
323     {
324     int rightval;
325    
326     DO (cp = parse_shift (g, cp, valp));
327     SKIPSPACE (cp);
328    
329     switch (*cp) {
330     case '<':
331     if (cp[1] == '=') {
332     DO (cp = parse_inequality (g, cp + 2, &rightval));
333     *valp = (*valp <= rightval);
334     } else {
335     DO (cp = parse_inequality (g, cp + 1, &rightval));
336     *valp = (*valp < rightval);
337     }
338     break;
339    
340     case '>':
341     if (cp[1] == '=') {
342     DO (cp = parse_inequality (g, cp + 2, &rightval));
343     *valp = (*valp >= rightval);
344     } else {
345     DO (cp = parse_inequality (g, cp + 1, &rightval));
346     *valp = (*valp > rightval);
347     }
348     break;
349     }
350     return cp;
351     }
352    
353    
354     static const char *
355     parse_equality (g, cp, valp)
356     IfParser *g;
357     const char *cp;
358     int *valp;
359     {
360     int rightval;
361    
362     DO (cp = parse_inequality (g, cp, valp));
363     SKIPSPACE (cp);
364    
365     switch (*cp) {
366     case '=':
367     if (cp[1] == '=')
368     cp++;
369     DO (cp = parse_equality (g, cp + 1, &rightval));
370     *valp = (*valp == rightval);
371     break;
372    
373     case '!':
374     if (cp[1] != '=')
375     break;
376     DO (cp = parse_equality (g, cp + 2, &rightval));
377     *valp = (*valp != rightval);
378     break;
379     }
380     return cp;
381     }
382    
383    
384     static const char *
385     parse_band (g, cp, valp)
386     IfParser *g;
387     const char *cp;
388     int *valp;
389     {
390     int rightval;
391    
392     DO (cp = parse_equality (g, cp, valp));
393     SKIPSPACE (cp);
394    
395     switch (*cp) {
396     case '&':
397     if (cp[1] != '&') {
398     DO (cp = parse_band (g, cp + 1, &rightval));
399     *valp = (*valp & rightval);
400     }
401     break;
402     }
403     return cp;
404     }
405    
406    
407     static const char *
408     parse_bor (g, cp, valp)
409     IfParser *g;
410     const char *cp;
411     int *valp;
412     {
413     int rightval;
414    
415     DO (cp = parse_band (g, cp, valp));
416     SKIPSPACE (cp);
417    
418     switch (*cp) {
419     case '|':
420     if (cp[1] != '|') {
421     DO (cp = parse_bor (g, cp + 1, &rightval));
422     *valp = (*valp | rightval);
423     }
424     break;
425     }
426     return cp;
427     }
428    
429    
430     static const char *
431     parse_land (g, cp, valp)
432     IfParser *g;
433     const char *cp;
434     int *valp;
435     {
436     int rightval;
437    
438     DO (cp = parse_bor (g, cp, valp));
439     SKIPSPACE (cp);
440    
441     switch (*cp) {
442     case '&':
443     if (cp[1] != '&')
444     return CALLFUNC(g, handle_error) (g, cp, "&&");
445     DO (cp = parse_land (g, cp + 2, &rightval));
446     *valp = (*valp && rightval);
447     break;
448     }
449     return cp;
450     }
451    
452    
453     static const char *
454     parse_lor (g, cp, valp)
455     IfParser *g;
456     const char *cp;
457     int *valp;
458     {
459     int rightval;
460    
461     DO (cp = parse_land (g, cp, valp));
462     SKIPSPACE (cp);
463    
464     switch (*cp) {
465     case '|':
466     if (cp[1] != '|')
467     return CALLFUNC(g, handle_error) (g, cp, "||");
468     DO (cp = parse_lor (g, cp + 2, &rightval));
469     *valp = (*valp || rightval);
470     break;
471     }
472     return cp;
473     }
474    
475    
476     /****************************************************************************
477     External Entry Points
478     ****************************************************************************/
479    
480     const char *
481     ParseIfExpression (g, cp, valp)
482     IfParser *g;
483     const char *cp;
484     int *valp;
485     {
486     return parse_lor (g, cp, valp);
487     }
488    
489    

  ViewVC Help
Powered by ViewVC 1.1.22