Annotation of OpenXM_contrib/gmp/demos/expr/expr.c, Revision 1.1.1.1
1.1 ohara 1: /* mpexpr_evaluate -- shared code for simple expression evaluation */
2:
3: /*
4: Copyright 2000, 2001 Free Software Foundation, Inc.
5:
6: This file is part of the GNU MP Library.
7:
8: The GNU MP Library is free software; you can redistribute it and/or modify
9: it under the terms of the GNU Lesser General Public License as published by
10: the Free Software Foundation; either version 2.1 of the License, or (at your
11: option) any later version.
12:
13: The GNU MP Library is distributed in the hope that it will be useful, but
14: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
16: License for more details.
17:
18: You should have received a copy of the GNU Lesser General Public License
19: along with the GNU MP Library; see the file COPYING.LIB. If not, write to
20: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
21: MA 02111-1307, USA.
22: */
23:
24: #include <ctype.h>
25: #include <stdio.h>
26:
27: #include "gmp.h"
28: #include "expr-impl.h"
29:
30:
31: /* Change this to "#define TRACE(x) x" to get some traces. The trace
32: printfs junk up the code a bit, but it's very hard to tell what's going
33: on without them. Set MPX_TRACE to a suitable output function for the
34: mpz/mpq/mpf being run (if you have the wrong trace function it'll
35: probably segv). */
36:
37: #define TRACE(x)
38: #define MPX_TRACE mpfr_trace
39:
40:
41: #if 0
42: #include "tests.h"
43:
44: /* Print "name=value\n" to stdout for an mpf_t value. */
45: void
46: mpfr_trace (__gmp_const char *name, mpfr_srcptr f)
47: {
48: mp_trace_start (name);
49: mpfr_out_str (stdout, mp_trace_base, 0, f, GMP_RNDZ);
50: printf ("\n");
51: }
52: #endif
53:
54:
55: /* A few helper macros copied from gmp-impl.h */
56: #define __GMP_ALLOCATE_FUNC_TYPE(n,type) \
57: ((type *) (*__gmp_allocate_func) ((n) * sizeof (type)))
58: #define __GMP_ALLOCATE_FUNC_LIMBS(n) __GMP_ALLOCATE_FUNC_TYPE (n, mp_limb_t)
59: #define __GMP_REALLOCATE_FUNC_TYPE(p, old_size, new_size, type) \
60: ((type *) (*__gmp_reallocate_func) \
61: (p, (old_size) * sizeof (type), (new_size) * sizeof (type)))
62: #define __GMP_REALLOCATE_FUNC_LIMBS(p, old_size, new_size) \
63: __GMP_REALLOCATE_FUNC_TYPE(p, old_size, new_size, mp_limb_t)
64: #define __GMP_FREE_FUNC_TYPE(p,n,type) (*__gmp_free_func) (p, (n) * sizeof (type))
65: #define __GMP_FREE_FUNC_LIMBS(p,n) __GMP_FREE_FUNC_TYPE (p, n, mp_limb_t)
66: #define ASSERT(x)
67:
68:
69:
70: /* All the error strings are just for diagnostic traces. Only the error
71: code is actually returned. */
72: #define ERROR(str,code) \
73: { \
74: TRACE (printf ("%s\n", str)); \
75: p->error_code = (code); \
76: goto done; \
77: }
78:
79:
80: #define REALLOC(ptr, alloc, incr, type) \
81: do { \
82: int new_alloc = (alloc) + (incr); \
83: ptr = __GMP_REALLOCATE_FUNC_TYPE (ptr, alloc, new_alloc, type); \
84: (alloc) = new_alloc; \
85: } while (0)
86:
87:
88: /* data stack top element */
89: #define SP (p->data_stack + p->data_top)
90:
91: /* make sure there's room for another data element above current top */
92: #define DATA_SPACE() \
93: do { \
94: if (p->data_top + 1 >= p->data_alloc) \
95: { \
96: TRACE (printf ("grow stack from %d\n", p->data_alloc)); \
97: REALLOC (p->data_stack, p->data_alloc, 20, union mpX_t); \
98: } \
99: ASSERT (p->data_top + 1 <= p->data_inited); \
100: if (p->data_top + 1 == p->data_inited) \
101: { \
102: TRACE (printf ("initialize %d\n", p->data_top + 1)); \
103: (*p->mpX_init) (&p->data_stack[p->data_top + 1], p->prec); \
104: p->data_inited++; \
105: } \
106: } while (0)
107:
108: #define DATA_PUSH() \
109: do { \
110: p->data_top++; \
111: ASSERT (p->data_top < p->data_alloc); \
112: ASSERT (p->data_top < p->data_inited); \
113: } while (0)
114:
115: /* the last stack entry is never popped, so top>=0 will be true */
116: #define DATA_POP(n) \
117: do { \
118: p->data_top -= (n); \
119: ASSERT (p->data_top >= 0); \
120: } while (0)
121:
122:
123: /* lookahead() parses the next token. Return 1 if successful, with some
124: extra data. Return 0 if fail, with reason in p->error_code.
125:
126: "prefix" is MPEXPR_TYPE_PREFIX if an operator with that attribute is
127: preferred, or 0 if an operator without is preferred. */
128:
129: #define TOKEN_EOF -1 /* no extra data */
130: #define TOKEN_VALUE -2 /* pushed onto data stack */
131: #define TOKEN_OPERATOR -3 /* stored in p->token_op */
132: #define TOKEN_FUNCTION -4 /* stored in p->token_op */
133:
134: #define TOKEN_NAME(n) \
135: ((n) == TOKEN_EOF ? "TOKEN_EOF" \
136: : (n) == TOKEN_VALUE ? "TOKEN_VALUE" \
137: : (n) == TOKEN_OPERATOR ? "TOKEN_OPERATOR" \
138: : (n) == TOKEN_VALUE ? "TOKEN_FUNCTION" \
139: : "UNKNOWN TOKEN")
140:
141: /* Functions default to being parsed as whole words, operators to match just
142: at the start of the string. The type flags override this. */
143: #define WHOLEWORD(op) \
144: (op->precedence == 0 \
145: ? (! (op->type & MPEXPR_TYPE_OPERATOR)) \
146: : (op->type & MPEXPR_TYPE_WHOLEWORD))
147:
148: #define isasciispace(c) (isascii (c) && isspace (c))
149:
150: static int
151: lookahead (struct mpexpr_parse_t *p, int prefix)
152: {
153: __gmp_const struct mpexpr_operator_t *op, *op_found;
154: size_t oplen, oplen_found, wlen;
155: int i;
156:
157: /* skip white space */
158: while (p->elen > 0 && isasciispace (*p->e))
159: p->e++, p->elen--;
160:
161: if (p->elen == 0)
162: {
163: TRACE (printf ("lookahead EOF\n"));
164: p->token = TOKEN_EOF;
165: return 1;
166: }
167:
168: DATA_SPACE ();
169:
170: /* Get extent of whole word. */
171: for (wlen = 0; wlen < p->elen; wlen++)
172: if (! isasciicsym (p->e[wlen]))
173: break;
174:
175: TRACE (printf ("lookahead at: \"%.*s\" length %u, word %u\n",
176: (int) p->elen, p->e, p->elen, wlen));
177:
178: op_found = NULL;
179: oplen_found = 0;
180: for (op = p->table; op->name != NULL; op++)
181: {
182: if (op->type == MPEXPR_TYPE_NEW_TABLE)
183: {
184: printf ("new\n");
185: op = (struct mpexpr_operator_t *) op->name - 1;
186: continue;
187: }
188:
189: oplen = strlen (op->name);
190: if (! ((WHOLEWORD (op) ? wlen == oplen : p->elen >= oplen)
191: && memcmp (p->e, op->name, oplen) == 0))
192: continue;
193:
194: /* Shorter matches don't replace longer previous ones. */
195: if (op_found && oplen < oplen_found)
196: continue;
197:
198: /* On a match of equal length to a previous one, the old match isn't
199: replaced if it has the preferred prefix, and if it doesn't then
200: it's not replaced if the new one also doesn't. */
201: if (op_found && oplen == oplen_found
202: && ((op_found->type & MPEXPR_TYPE_PREFIX) == prefix
203: || (op->type & MPEXPR_TYPE_PREFIX) != prefix))
204: continue;
205:
206: /* This is now either the first match seen, or a longer than previous
207: match, or an equal to previous one but with a preferred prefix. */
208: op_found = op;
209: oplen_found = oplen;
210: }
211:
212: if (op_found)
213: {
214: p->e += oplen_found, p->elen -= oplen_found;
215:
216: if (op_found->type == MPEXPR_TYPE_VARIABLE)
217: {
218: if (p->elen == 0)
219: ERROR ("end of string expecting a variable",
220: MPEXPR_RESULT_PARSE_ERROR);
221: i = p->e[0] - 'a';
222: if (i < 0 || i >= MPEXPR_VARIABLES)
223: ERROR ("bad variable name", MPEXPR_RESULT_BAD_VARIABLE);
224: goto variable;
225: }
226:
227: if (op_found->precedence == 0)
228: {
229: TRACE (printf ("lookahead function: %s\n", op_found->name));
230: p->token = TOKEN_FUNCTION;
231: p->token_op = op_found;
232: return 1;
233: }
234: else
235: {
236: TRACE (printf ("lookahead operator: %s\n", op_found->name));
237: p->token = TOKEN_OPERATOR;
238: p->token_op = op_found;
239: return 1;
240: }
241: }
242:
243: oplen = (*p->mpX_number) (SP+1, p->e, p->elen, p->base);
244: if (oplen != 0)
245: {
246: p->e += oplen, p->elen -= oplen;
247: p->token = TOKEN_VALUE;
248: DATA_PUSH ();
249: TRACE (MPX_TRACE ("lookahead number", SP));
250: return 1;
251: }
252:
253: /* Maybe an unprefixed one character variable */
254: i = p->e[0] - 'a';
255: if (wlen == 1 && i >= 0 && i < MPEXPR_VARIABLES)
256: {
257: variable:
258: p->e++, p->elen--;
259: if (p->var[i] == NULL)
260: ERROR ("NULL variable", MPEXPR_RESULT_BAD_VARIABLE);
261: TRACE (printf ("lookahead variable: var[%d] = ", i);
262: MPX_TRACE ("", p->var[i]));
263: p->token = TOKEN_VALUE;
264: DATA_PUSH ();
265: (*p->mpX_set) (SP, p->var[i]);
266: return 1;
267: }
268:
269: ERROR ("no token matched", MPEXPR_RESULT_PARSE_ERROR);
270:
271: done:
272: return 0;
273: }
274:
275:
276: /* control stack current top element */
277: #define CP (p->control_stack + p->control_top)
278:
279: /* make sure there's room for another control element above current top */
280: #define CONTROL_SPACE() \
281: do { \
282: if (p->control_top + 1 >= p->control_alloc) \
283: { \
284: TRACE (printf ("grow control stack from %d\n", p->control_alloc)); \
285: REALLOC (p->control_stack, p->control_alloc, 20, \
286: struct mpexpr_control_t); \
287: } \
288: } while (0)
289:
290: /* Push an operator on the control stack, claiming currently to have the
291: given number of args ready. Local variable "op" is used in case opptr is
292: a reference through CP. */
293: #define CONTROL_PUSH(opptr,args) \
294: do { \
295: __gmp_const struct mpexpr_operator_t *op = opptr; \
296: struct mpexpr_control_t *cp; \
297: CONTROL_SPACE (); \
298: p->control_top++; \
299: ASSERT (p->control_top < p->control_alloc); \
300: cp = CP; \
301: cp->op = op; \
302: cp->argcount = (args); \
303: TRACE_CONTROL("control stack push:"); \
304: } while (0)
305:
306: /* The special operator_done is never popped, so top>=0 will hold. */
307: #define CONTROL_POP() \
308: do { \
309: p->control_top--; \
310: ASSERT (p->control_top >= 0); \
311: TRACE_CONTROL ("control stack pop:"); \
312: } while (0)
313:
314: #define TRACE_CONTROL(str) \
315: TRACE ({ \
316: int i; \
317: printf ("%s depth %d:", str, p->control_top); \
318: for (i = 0; i <= p->control_top; i++) \
319: printf (" \"%s\"(%d)", \
320: p->control_stack[i].op->name, \
321: p->control_stack[i].argcount); \
322: printf ("\n"); \
323: });
324:
325:
326: #define LOOKAHEAD(prefix) \
327: do { \
328: if (! lookahead (p, prefix)) \
329: goto done; \
330: } while (0)
331:
332: #define CHECK_UI(n) \
333: do { \
334: if (! (*p->mpX_ulong_p) (n)) \
335: ERROR ("operand doesn't fit ulong", MPEXPR_RESULT_NOT_UI); \
336: } while (0)
337:
338: #define CHECK_ARGCOUNT(str,n) \
339: do { \
340: if (CP->argcount != (n)) \
341: { \
342: TRACE (printf ("wrong number of arguments for %s, got %d want %d", \
343: str, CP->argcount, n)); \
344: ERROR ("", MPEXPR_RESULT_PARSE_ERROR); \
345: } \
346: } while (0)
347:
348:
349: /* There's two basic states here. In both p->token is the next token.
350:
351: "another_expr" is when a whole expression should be parsed. This means a
352: literal or variable value possibly followed by an operator, or a function
353: or prefix operator followed by a further whole expression.
354:
355: "another_operator" is when an expression has been parsed and its value is
356: on the top of the data stack (SP) and an optional further postfix or
357: infix operator should be parsed.
358:
359: In "another_operator" precedences determine whether to push the operator
360: onto the control stack, or instead go to "apply_control" to reduce the
361: operator currently on top of the control stack.
362:
363: When an operator has both a prefix and postfix/infix form, a LOOKAHEAD()
364: for "another_expr" will seek the prefix form, a LOOKAHEAD() for
365: "another_operator" will seek the postfix/infix form. The grammar is
366: simple enough that the next state is known before reading the next token.
367:
368: Argument count checking guards against functions consuming the wrong
369: number of operands from the data stack. The same checks are applied to
370: operators, but will always pass since a UNARY or BINARY will only ever
371: parse with the correct operands. */
372:
373: int
374: mpexpr_evaluate (struct mpexpr_parse_t *p)
375: {
376: TRACE (printf ("mpexpr_evaluate() base %d \"%.*s\"\n",
377: p->base, (int) p->elen, p->e));
378:
379: /* "done" is a special sentinel at the bottom of the control stack,
380: precedence -1 is lower than any normal operator. */
381: {
382: static __gmp_const struct mpexpr_operator_t operator_done
383: = { "DONE", NULL, MPEXPR_TYPE_DONE, -1 };
384:
385: p->control_alloc = 20;
386: p->control_stack = __GMP_ALLOCATE_FUNC_TYPE (p->control_alloc,
387: struct mpexpr_control_t);
388: p->control_top = 0;
389: CP->op = &operator_done;
390: CP->argcount = 1;
391: }
392:
393: p->data_inited = 0;
394: p->data_alloc = 20;
395: p->data_stack = __GMP_ALLOCATE_FUNC_TYPE (p->data_alloc, union mpX_t);
396: p->data_top = -1;
397:
398: p->error_code = MPEXPR_RESULT_OK;
399:
400:
401: another_expr_lookahead:
402: LOOKAHEAD (MPEXPR_TYPE_PREFIX);
403: TRACE (printf ("another expr\n"));
404:
405: /*another_expr:*/
406: switch (p->token) {
407: case TOKEN_VALUE:
408: goto another_operator_lookahead;
409:
410: case TOKEN_OPERATOR:
411: TRACE (printf ("operator %s\n", p->token_op->name));
412: if (! (p->token_op->type & MPEXPR_TYPE_PREFIX))
413: ERROR ("expected a prefix operator", MPEXPR_RESULT_PARSE_ERROR);
414:
415: CONTROL_PUSH (p->token_op, 1);
416: goto another_expr_lookahead;
417:
418: case TOKEN_FUNCTION:
419: CONTROL_PUSH (p->token_op, 1);
420:
421: if (p->token_op->type & MPEXPR_TYPE_CONSTANT)
422: goto apply_control_lookahead;
423:
424: LOOKAHEAD (MPEXPR_TYPE_PREFIX);
425: if (! (p->token == TOKEN_OPERATOR
426: && p->token_op->type == MPEXPR_TYPE_OPENPAREN))
427: ERROR ("expected open paren for function", MPEXPR_RESULT_PARSE_ERROR);
428:
429: TRACE (printf ("open paren for function \"%s\"\n", CP->op->name));
430:
431: if ((CP->op->type & MPEXPR_TYPE_MASK_ARGCOUNT) == MPEXPR_TYPE_NARY(0))
432: {
433: LOOKAHEAD (0);
434: if (! (p->token == TOKEN_OPERATOR
435: && p->token_op->type == MPEXPR_TYPE_CLOSEPAREN))
436: ERROR ("expected close paren for 0ary function",
437: MPEXPR_RESULT_PARSE_ERROR);
438: goto apply_control_lookahead;
439: }
440:
441: goto another_expr_lookahead;
442: }
443: ERROR ("unrecognised start of expression", MPEXPR_RESULT_PARSE_ERROR);
444:
445:
446: another_operator_lookahead:
447: LOOKAHEAD (0);
448: another_operator:
449: TRACE (printf ("another operator maybe: %s\n", TOKEN_NAME(p->token)));
450:
451: switch (p->token) {
452: case TOKEN_EOF:
453: goto apply_control;
454:
455: case TOKEN_OPERATOR:
456: /* The next operator is compared to the one on top of the control stack.
457: If the next is lower precedence, or the same precedence and not
458: right-associative, then reduce using the control stack and look at
459: the next operator again later. */
460:
461: #define PRECEDENCE_TEST_REDUCE(tprec,cprec,ttype,ctype) \
462: ((tprec) < (cprec) \
463: || ((tprec) == (cprec) && ! ((ttype) & MPEXPR_TYPE_RIGHTASSOC)))
464:
465: if (PRECEDENCE_TEST_REDUCE (p->token_op->precedence, CP->op->precedence,
466: p->token_op->type, CP->op->type))
467: {
468: TRACE (printf ("defer operator: %s (prec %d vs %d, type 0x%X)\n",
469: p->token_op->name,
470: p->token_op->precedence, CP->op->precedence,
471: p->token_op->type));
472: goto apply_control;
473: }
474:
475: /* An argsep is a binary operator, but is never pushed on the control
476: stack, it just accumulates an extra argument for a function. */
477: if (p->token_op->type == MPEXPR_TYPE_ARGSEP)
478: {
479: if (CP->op->precedence != 0)
480: ERROR ("ARGSEP not in a function call", MPEXPR_RESULT_PARSE_ERROR);
481:
482: TRACE (printf ("argsep for function \"%s\"(%d)\n",
483: CP->op->name, CP->argcount));
484:
485: #define IS_PAIRWISE(type) \
486: (((type) & (MPEXPR_TYPE_MASK_ARGCOUNT | MPEXPR_TYPE_PAIRWISE)) \
487: == (MPEXPR_TYPE_BINARY | MPEXPR_TYPE_PAIRWISE))
488:
489: if (IS_PAIRWISE (CP->op->type) && CP->argcount >= 2)
490: {
491: TRACE (printf (" will reduce pairwise now\n"));
492: CP->argcount--;
493: CONTROL_PUSH (CP->op, 2);
494: goto apply_control;
495: }
496:
497: CP->argcount++;
498: goto another_expr_lookahead;
499: }
500:
501: switch (p->token_op->type & MPEXPR_TYPE_MASK_ARGCOUNT) {
502: case MPEXPR_TYPE_NARY(1):
503: /* Postfix unary operators can always be applied immediately. The
504: easiest way to do this is just push it on the control stack and go
505: to the normal control stack reduction code. */
506:
507: TRACE (printf ("postfix unary operator: %s\n", p->token_op->name));
508: if (p->token_op->type & MPEXPR_TYPE_PREFIX)
509: ERROR ("prefix unary operator used postfix",
510: MPEXPR_RESULT_PARSE_ERROR);
511: CONTROL_PUSH (p->token_op, 1);
512: goto apply_control_lookahead;
513:
514: case MPEXPR_TYPE_NARY(2):
515: CONTROL_PUSH (p->token_op, 2);
516: goto another_expr_lookahead;
517:
518: case MPEXPR_TYPE_NARY(3):
519: CONTROL_PUSH (p->token_op, 1);
520: goto another_expr_lookahead;
521: }
522:
523: TRACE (printf ("unrecognised operator \"%s\" type: 0x%X",
524: CP->op->name, CP->op->type));
525: ERROR ("", MPEXPR_RESULT_PARSE_ERROR);
526: break;
527:
528: default:
529: TRACE (printf ("expecting an operator, got token %d", p->token));
530: ERROR ("", MPEXPR_RESULT_PARSE_ERROR);
531: }
532:
533:
534: apply_control_lookahead:
535: LOOKAHEAD (0);
536: apply_control:
537: /* Apply the top element CP of the control stack. Data values are SP,
538: SP-1, etc. Result is left as stack top SP after popping consumed
539: values.
540:
541: The use of sp as a duplicate of SP will help compilers that can't
542: otherwise recognise the various uses of SP as common subexpressions. */
543:
544: TRACE (printf ("apply control: nested %d, \"%s\" 0x%X, %d args\n",
545: p->control_top, CP->op->name, CP->op->type, CP->argcount));
546:
547: TRACE (printf ("apply 0x%X-ary\n",
548: CP->op->type & MPEXPR_TYPE_MASK_ARGCOUNT));
549: switch (CP->op->type & MPEXPR_TYPE_MASK_ARGCOUNT) {
550: case MPEXPR_TYPE_NARY(0):
551: {
552: mpX_ptr sp;
553: DATA_SPACE ();
554: DATA_PUSH ();
555: sp = SP;
556: switch (CP->op->type & MPEXPR_TYPE_MASK_ARGSTYLE) {
557: case 0:
558: (* (mpexpr_fun_0ary_t) CP->op->fun) (sp);
559: break;
560: case MPEXPR_TYPE_RESULT_INT:
561: (*p->mpX_set_si) (sp, (long) (* (mpexpr_fun_i_0ary_t) CP->op->fun) ());
562: break;
563: default:
564: ERROR ("unrecognised 0ary argument calling style",
565: MPEXPR_RESULT_BAD_TABLE);
566: }
567: }
568: break;
569:
570: case MPEXPR_TYPE_NARY(1):
571: {
572: mpX_ptr sp = SP;
573: CHECK_ARGCOUNT ("unary", 1);
574: TRACE (MPX_TRACE ("before", sp));
575:
576: switch (CP->op->type & MPEXPR_TYPE_MASK_SPECIAL) {
577: case 0:
578: /* not a special */
579: break;
580:
581: case MPEXPR_TYPE_DONE & MPEXPR_TYPE_MASK_SPECIAL:
582: TRACE (printf ("special done\n"));
583: goto done;
584:
585: case MPEXPR_TYPE_LOGICAL_NOT & MPEXPR_TYPE_MASK_SPECIAL:
586: TRACE (printf ("special logical not\n"));
587: (*p->mpX_set_si)
588: (sp, (long) ((* (mpexpr_fun_i_unary_t) CP->op->fun) (sp) == 0));
589: goto apply_control_done;
590:
591: case MPEXPR_TYPE_CLOSEPAREN & MPEXPR_TYPE_MASK_SPECIAL:
592: CONTROL_POP ();
593: if (CP->op->type == MPEXPR_TYPE_OPENPAREN)
594: {
595: TRACE (printf ("close paren matching open paren\n"));
596: CONTROL_POP ();
597: goto another_operator;
598: }
599: if (CP->op->precedence == 0)
600: {
601: TRACE (printf ("close paren for function\n"));
602: goto apply_control;
603: }
604: ERROR ("unexpected close paren", MPEXPR_RESULT_PARSE_ERROR);
605:
606: default:
607: TRACE (printf ("unrecognised special unary operator 0x%X",
608: CP->op->type & MPEXPR_TYPE_MASK_SPECIAL));
609: ERROR ("", MPEXPR_RESULT_BAD_TABLE);
610: }
611:
612: switch (CP->op->type & MPEXPR_TYPE_MASK_ARGSTYLE) {
613: case 0:
614: (* (mpexpr_fun_unary_t) CP->op->fun) (sp, sp);
615: break;
616: case MPEXPR_TYPE_LAST_UI:
617: CHECK_UI (sp);
618: (* (mpexpr_fun_unary_ui_t) CP->op->fun)
619: (sp, (*p->mpX_get_ui) (sp));
620: break;
621: case MPEXPR_TYPE_RESULT_INT:
622: (*p->mpX_set_si)
623: (sp, (long) (* (mpexpr_fun_i_unary_t) CP->op->fun) (sp));
624: break;
625: case MPEXPR_TYPE_RESULT_INT | MPEXPR_TYPE_LAST_UI:
626: CHECK_UI (sp);
627: (*p->mpX_set_si)
628: (sp,
629: (long) (* (mpexpr_fun_i_unary_ui_t) CP->op->fun)
630: ((*p->mpX_get_ui) (sp)));
631: break;
632: default:
633: ERROR ("unrecognised unary argument calling style",
634: MPEXPR_RESULT_BAD_TABLE);
635: }
636: }
637: break;
638:
639: case MPEXPR_TYPE_NARY(2):
640: {
641: mpX_ptr sp;
642:
643: /* pairwise functions are allowed to have just one argument */
644: if ((CP->op->type & MPEXPR_TYPE_PAIRWISE)
645: && CP->op->precedence == 0
646: && CP->argcount == 1)
647: goto apply_control_done;
648:
649: CHECK_ARGCOUNT ("binary", 2);
650: DATA_POP (1);
651: sp = SP;
652: TRACE (MPX_TRACE ("lhs", sp);
653: MPX_TRACE ("rhs", sp+1));
654:
655: if (CP->op->type & MPEXPR_TYPE_MASK_CMP)
656: {
657: int type = CP->op->type;
658: int cmp = (* (mpexpr_fun_i_binary_t) CP->op->fun)
659: (sp, sp+1);
660: (*p->mpX_set_si)
661: (sp,
662: (long)
663: (( (cmp < 0) & ((type & MPEXPR_TYPE_MASK_CMP_LT) != 0))
664: | ((cmp == 0) & ((type & MPEXPR_TYPE_MASK_CMP_EQ) != 0))
665: | ((cmp > 0) & ((type & MPEXPR_TYPE_MASK_CMP_GT) != 0))));
666: goto apply_control_done;
667: }
668:
669: switch (CP->op->type & MPEXPR_TYPE_MASK_SPECIAL) {
670: case 0:
671: /* not a special */
672: break;
673:
674: case MPEXPR_TYPE_QUESTION & MPEXPR_TYPE_MASK_SPECIAL:
675: ERROR ("'?' without ':'", MPEXPR_RESULT_PARSE_ERROR);
676:
677: case MPEXPR_TYPE_COLON & MPEXPR_TYPE_MASK_SPECIAL:
678: TRACE (printf ("special colon\n"));
679: CONTROL_POP ();
680: if (CP->op->type != MPEXPR_TYPE_QUESTION)
681: ERROR ("':' without '?'", MPEXPR_RESULT_PARSE_ERROR);
682:
683: CP->argcount--;
684: DATA_POP (1);
685: sp--;
686: TRACE (MPX_TRACE ("query", sp);
687: MPX_TRACE ("true", sp+1);
688: MPX_TRACE ("false", sp+2));
689: (*p->mpX_set)
690: (sp, (* (mpexpr_fun_i_unary_t) CP->op->fun) (sp)
691: ? sp+1 : sp+2);
692: goto apply_control_done;
693:
694: case MPEXPR_TYPE_LOGICAL_AND & MPEXPR_TYPE_MASK_SPECIAL:
695: TRACE (printf ("special logical and\n"));
696: (*p->mpX_set_si)
697: (sp,
698: (long)
699: ((* (mpexpr_fun_i_unary_t) CP->op->fun) (sp)
700: && (* (mpexpr_fun_i_unary_t) CP->op->fun) (sp+1)));
701: goto apply_control_done;
702:
703: case MPEXPR_TYPE_LOGICAL_OR & MPEXPR_TYPE_MASK_SPECIAL:
704: TRACE (printf ("special logical and\n"));
705: (*p->mpX_set_si)
706: (sp,
707: (long)
708: ((* (mpexpr_fun_i_unary_t) CP->op->fun) (sp)
709: || (* (mpexpr_fun_i_unary_t) CP->op->fun) (sp+1)));
710: goto apply_control_done;
711:
712: case MPEXPR_TYPE_MAX & MPEXPR_TYPE_MASK_SPECIAL:
713: TRACE (printf ("special max\n"));
714: if ((* (mpexpr_fun_i_binary_t) CP->op->fun) (sp, sp+1) < 0)
715: (*p->mpX_swap) (sp, sp+1);
716: goto apply_control_done;
717: case MPEXPR_TYPE_MIN & MPEXPR_TYPE_MASK_SPECIAL:
718: TRACE (printf ("special min\n"));
719: if ((* (mpexpr_fun_i_binary_t) CP->op->fun) (sp, sp+1) > 0)
720: (*p->mpX_swap) (sp, sp+1);
721: goto apply_control_done;
722:
723: default:
724: ERROR ("unrecognised special binary operator",
725: MPEXPR_RESULT_BAD_TABLE);
726: }
727:
728: switch (CP->op->type & MPEXPR_TYPE_MASK_ARGSTYLE) {
729: case 0:
730: (* (mpexpr_fun_binary_t) CP->op->fun) (sp, sp, sp+1);
731: break;
732: case MPEXPR_TYPE_LAST_UI:
733: CHECK_UI (sp+1);
734: (* (mpexpr_fun_binary_ui_t) CP->op->fun)
735: (sp, sp, (*p->mpX_get_ui) (sp+1));
736: break;
737: case MPEXPR_TYPE_RESULT_INT:
738: (*p->mpX_set_si)
739: (sp,
740: (long) (* (mpexpr_fun_i_binary_t) CP->op->fun) (sp, sp+1));
741: break;
742: case MPEXPR_TYPE_LAST_UI | MPEXPR_TYPE_RESULT_INT:
743: CHECK_UI (sp+1);
744: (*p->mpX_set_si)
745: (sp,
746: (long) (* (mpexpr_fun_i_binary_ui_t) CP->op->fun)
747: (sp, (*p->mpX_get_ui) (sp+1)));
748: break;
749: default:
750: ERROR ("unrecognised binary argument calling style",
751: MPEXPR_RESULT_BAD_TABLE);
752: }
753: }
754: break;
755:
756: case MPEXPR_TYPE_NARY(3):
757: {
758: mpX_ptr sp;
759:
760: CHECK_ARGCOUNT ("ternary", 3);
761: DATA_POP (2);
762: sp = SP;
763: TRACE (MPX_TRACE ("arg1", sp);
764: MPX_TRACE ("arg2", sp+1);
765: MPX_TRACE ("arg3", sp+1));
766:
767: switch (CP->op->type & MPEXPR_TYPE_MASK_ARGSTYLE) {
768: case 0:
769: (* (mpexpr_fun_ternary_t) CP->op->fun) (sp, sp, sp+1, sp+2);
770: break;
771: case MPEXPR_TYPE_LAST_UI:
772: CHECK_UI (sp+2);
773: (* (mpexpr_fun_ternary_ui_t) CP->op->fun)
774: (sp, sp, sp+1, (*p->mpX_get_ui) (sp+2));
775: break;
776: case MPEXPR_TYPE_RESULT_INT:
777: (*p->mpX_set_si)
778: (sp,
779: (long) (* (mpexpr_fun_i_ternary_t) CP->op->fun)
780: (sp, sp+1, sp+2));
781: break;
782: case MPEXPR_TYPE_LAST_UI | MPEXPR_TYPE_RESULT_INT:
783: CHECK_UI (sp+2);
784: (*p->mpX_set_si)
785: (sp,
786: (long) (* (mpexpr_fun_i_ternary_ui_t) CP->op->fun)
787: (sp, sp+1, (*p->mpX_get_ui) (sp+2)));
788: break;
789: default:
790: ERROR ("unrecognised binary argument calling style",
791: MPEXPR_RESULT_BAD_TABLE);
792: }
793: }
794: break;
795:
796: default:
797: TRACE (printf ("unrecognised operator type: 0x%X\n", CP->op->type));
798: ERROR ("", MPEXPR_RESULT_PARSE_ERROR);
799: }
800:
801: apply_control_done:
802: TRACE (MPX_TRACE ("result", SP));
803: CONTROL_POP ();
804: goto another_operator;
805:
806: done:
807: if (p->error_code == MPEXPR_RESULT_OK)
808: {
809: if (p->data_top != 0)
810: {
811: TRACE (printf ("data stack want top at 0, got %d\n", p->data_top));
812: p->error_code = MPEXPR_RESULT_PARSE_ERROR;
813: }
814: else
815: (*p->mpX_set_or_swap) (p->res, SP);
816: }
817:
818: {
819: int i;
820: for (i = 0; i < p->data_inited; i++)
821: {
822: TRACE (printf ("clear %d\n", i));
823: (*p->mpX_clear) (p->data_stack+i);
824: }
825: }
826:
827: __GMP_FREE_FUNC_TYPE (p->data_stack, p->data_alloc, union mpX_t);
828: __GMP_FREE_FUNC_TYPE (p->control_stack, p->control_alloc,
829: struct mpexpr_control_t);
830:
831: return p->error_code;
832: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to expr.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / demos / expr