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

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

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


Revision 1.1 - (show annotations) (download)
Wed Feb 25 18:19:54 2004 UTC (16 years, 11 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 /*
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