Annotation of OpenXM_contrib/gmp/demos/calc/calc.y, Revision 1.1
1.1 ! ohara 1: %{
! 2: /* A simple integer desk calculator using yacc and gmp.
! 3:
! 4: Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
! 5:
! 6: This file is part of the GNU MP Library.
! 7:
! 8: This program is free software; you can redistribute it and/or modify it under
! 9: the terms of the GNU General Public License as published by the Free Software
! 10: Foundation; either version 2 of the License, or (at your option) any later
! 11: version.
! 12:
! 13: This program is distributed in the hope that it will be useful, but WITHOUT ANY
! 14: WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
! 15: PARTICULAR PURPOSE. See the GNU General Public License for more details.
! 16:
! 17: You should have received a copy of the GNU General Public License along with
! 18: this program; if not, write to the Free Software Foundation, Inc., 59 Temple
! 19: Place - Suite 330, Boston, MA 02111-1307, USA. */
! 20:
! 21:
! 22: /* This is a simple program, meant only to show one way to use GMP for this
! 23: sort of thing. There's few features, and error checking is minimal.
! 24: Standard input is read, calc_help() below shows the inputs accepted.
! 25:
! 26: Expressions are evaluated as they're read. If user defined functions
! 27: were wanted it'd be necessary to build a parse tree like pexpr.c does, or
! 28: a list of operations for a stack based evaluator. That would also make
! 29: it possible to detect and optimize evaluations "mod m" like pexpr.c does.
! 30:
! 31: A stack is used for intermediate values in the expression evaluation,
! 32: separate from the yacc parser stack. This is simple, makes error
! 33: recovery easy, minimizes the junk around mpz calls in the rules, and
! 34: saves initializing or clearing "mpz_t"s during a calculation. A
! 35: disadvantage though is that variables must be copied to the stack to be
! 36: worked on. A more sophisticated calculator or language system might be
! 37: able to avoid that when executing a compiled or semi-compiled form.
! 38:
! 39: Avoiding repeated initializing and clearing of "mpz_t"s is important. In
! 40: this program the time spent parsing is obviously much greater than any
! 41: possible saving from this, but a proper calculator or language should
! 42: take some trouble over it. Don't be surprised if an init/clear takes 3
! 43: or more times as long as a 10 limb addition, depending on the system (see
! 44: the mpz_init_realloc_clear example in tune/README). */
! 45:
! 46:
! 47: #include <stdio.h>
! 48: #include <stdlib.h>
! 49: #include <string.h>
! 50: #include "gmp.h"
! 51: #define NO_CALC_H /* because it conflicts with normal calc.c stuff */
! 52: #include "calc-common.h"
! 53:
! 54:
! 55: #define numberof(x) (sizeof (x) / sizeof ((x)[0]))
! 56:
! 57:
! 58: void
! 59: calc_help (void)
! 60: {
! 61: printf ("Examples:\n");
! 62: printf (" 2+3*4 expressions are evaluated\n");
! 63: printf (" x=5^6 variables a to z can be set and used\n");
! 64: printf ("Operators:\n");
! 65: printf (" + - * arithmetic\n");
! 66: printf (" / %% division and remainder (rounding towards negative infinity)\n");
! 67: printf (" ^ exponentiation\n");
! 68: printf (" ! factorial\n");
! 69: printf (" << >> left and right shifts\n");
! 70: printf (" <= >= > \\ comparisons, giving 1 if true, 0 if false\n");
! 71: printf (" == != < /\n");
! 72: printf (" && || logical and/or, giving 1 if true, 0 if false\n");
! 73: printf ("Functions:\n");
! 74: printf (" abs(n) absolute value\n");
! 75: printf (" bin(n,m) binomial coefficient\n");
! 76: printf (" fib(n) fibonacci number\n");
! 77: printf (" gcd(a,b,..) greatest common divisor\n");
! 78: printf (" kron(a,b) kronecker symbol\n");
! 79: printf (" lcm(a,b,..) least common multiple\n");
! 80: printf (" lucnum(n) lucas number\n");
! 81: printf (" nextprime(n) next prime after n\n");
! 82: printf (" powm(b,e,m) modulo powering, b^e%%m\n");
! 83: printf (" root(n,r) r-th root\n");
! 84: printf (" sqrt(n) square root\n");
! 85: printf ("Other:\n");
! 86: printf (" hex \\ set hex or decimal for input and output\n");
! 87: printf (" decimal / (\"0x\" can be used for hex too)\n");
! 88: printf (" quit exit program (EOF works too)\n");
! 89: printf (" ; statements are separated with a ; or newline\n");
! 90: printf (" \\ continue expressions with \\ before newline\n");
! 91: printf (" # xxx comments are # though to newline\n");
! 92: printf ("Hex numbers must be entered in upper case, to distinguish them from the\n");
! 93: printf ("variables a to f (like in bc).\n");
! 94: }
! 95:
! 96:
! 97: int ibase = 0;
! 98: int obase = 10;
! 99:
! 100:
! 101: /* The stack is a fixed size, which means there's a limit on the nesting
! 102: allowed in expressions. A more sophisticated program could let it grow
! 103: dynamically. */
! 104:
! 105: mpz_t stack[100];
! 106: mpz_ptr sp = stack[0];
! 107:
! 108: #define CHECK_OVERFLOW() \
! 109: if (sp >= stack[numberof(stack)]) \
! 110: { \
! 111: fprintf (stderr, \
! 112: "Value stack overflow, too much nesting in expression\n"); \
! 113: YYERROR; \
! 114: }
! 115:
! 116: #define CHECK_EMPTY() \
! 117: if (sp != stack[0]) \
! 118: { \
! 119: fprintf (stderr, "Oops, expected the value stack to be empty\n"); \
! 120: sp = stack[0]; \
! 121: }
! 122:
! 123:
! 124: mpz_t variable[26];
! 125:
! 126: #define CHECK_VARIABLE(var) \
! 127: if ((var) < 0 || (var) >= numberof (variable)) \
! 128: { \
! 129: fprintf (stderr, "Oops, bad variable somehow: %d\n", var); \
! 130: YYERROR; \
! 131: }
! 132:
! 133:
! 134: #define CHECK_UI(name,z) \
! 135: if (! mpz_fits_ulong_p (z)) \
! 136: { \
! 137: fprintf (stderr, "%s too big\n", name); \
! 138: YYERROR; \
! 139: }
! 140:
! 141: %}
! 142:
! 143: %union {
! 144: char *str;
! 145: int var;
! 146: }
! 147:
! 148: %token EOS BAD
! 149: %token HELP HEX DECIMAL QUIT
! 150: %token ABS BIN FIB GCD KRON LCM LUCNUM NEXTPRIME POWM ROOT SQRT
! 151: %token <str> NUMBER
! 152: %token <var> VARIABLE
! 153:
! 154: /* operators, increasing precedence */
! 155: %left LOR
! 156: %left LAND
! 157: %nonassoc '<' '>' EQ NE LE GE
! 158: %left LSHIFT RSHIFT
! 159: %left '+' '-'
! 160: %left '*' '/' '%'
! 161: %nonassoc UMINUS
! 162: %right '^'
! 163: %nonassoc '!'
! 164:
! 165: %%
! 166:
! 167: top:
! 168: statement
! 169: | statements statement;
! 170:
! 171: statements:
! 172: statement EOS
! 173: | statements statement EOS
! 174: | error EOS { sp = stack[0]; yyerrok; };
! 175:
! 176: statement:
! 177: /* empty */
! 178: | e {
! 179: mpz_out_str (stdout, obase, sp); putchar ('\n');
! 180: sp--;
! 181: CHECK_EMPTY ();
! 182: }
! 183: | VARIABLE '=' e {
! 184: CHECK_VARIABLE ($1);
! 185: mpz_swap (variable[$1], sp);
! 186: sp--;
! 187: CHECK_EMPTY ();
! 188: }
! 189: | HELP { calc_help (); }
! 190: | HEX { ibase = 16; obase = -16; }
! 191: | DECIMAL { ibase = 0; obase = 10; }
! 192: | QUIT { exit (0); };
! 193:
! 194: /* "e" leaves it's value on the top of the mpz stack. A rule like "e '+' e"
! 195: will have done a reduction for the first "e" first and the second "e"
! 196: second, so the code receives the values in that order on the stack. */
! 197: e:
! 198: '(' e ')' /* value on stack */
! 199: | e '+' e { sp--; mpz_add (sp, sp, sp+1); }
! 200: | e '-' e { sp--; mpz_sub (sp, sp, sp+1); }
! 201: | e '*' e { sp--; mpz_mul (sp, sp, sp+1); }
! 202: | e '/' e { sp--; mpz_fdiv_q (sp, sp, sp+1); }
! 203: | e '%' e { sp--; mpz_fdiv_r (sp, sp, sp+1); }
! 204: | e '^' e { CHECK_UI ("Exponent", sp);
! 205: sp--; mpz_pow_ui (sp, sp, mpz_get_ui (sp+1)); }
! 206: | e LSHIFT e { CHECK_UI ("Shift count", sp);
! 207: sp--; mpz_mul_2exp (sp, sp, mpz_get_ui (sp+1)); }
! 208: | e RSHIFT e { CHECK_UI ("Shift count", sp);
! 209: sp--; mpz_fdiv_q_2exp (sp, sp, mpz_get_ui (sp+1)); }
! 210: | e '!' { CHECK_UI ("Factorial", sp);
! 211: mpz_fac_ui (sp, mpz_get_ui (sp)); }
! 212: | '-' e %prec UMINUS { mpz_neg (sp, sp); }
! 213:
! 214: | e '<' e { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) < 0); }
! 215: | e LE e { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) <= 0); }
! 216: | e EQ e { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) == 0); }
! 217: | e NE e { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) != 0); }
! 218: | e GE e { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) >= 0); }
! 219: | e '>' e { sp--; mpz_set_ui (sp, mpz_cmp (sp, sp+1) > 0); }
! 220:
! 221: | e LAND e { sp--; mpz_set_ui (sp, mpz_sgn (sp) && mpz_sgn (sp+1)); }
! 222: | e LOR e { sp--; mpz_set_ui (sp, mpz_sgn (sp) || mpz_sgn (sp+1)); }
! 223:
! 224: | ABS '(' e ')' { mpz_abs (sp, sp); }
! 225: | BIN '(' e ',' e ')' { sp--; CHECK_UI ("Binomial base", sp+1);
! 226: mpz_bin_ui (sp, sp, mpz_get_ui (sp+1)); }
! 227: | FIB '(' e ')' { CHECK_UI ("Fibonacci", sp);
! 228: mpz_fib_ui (sp, mpz_get_ui (sp)); }
! 229: | GCD '(' gcdlist ')' /* value on stack */
! 230: | KRON '(' e ',' e ')' { sp--; mpz_set_si (sp,
! 231: mpz_kronecker (sp, sp+1)); }
! 232: | LCM '(' lcmlist ')' /* value on stack */
! 233: | LUCNUM '(' e ')' { CHECK_UI ("Lucas number", sp);
! 234: mpz_lucnum_ui (sp, mpz_get_ui (sp)); }
! 235: | NEXTPRIME '(' e ')' { mpz_nextprime (sp, sp); }
! 236: | POWM '(' e ',' e ',' e ')' { sp -= 2; mpz_powm (sp, sp, sp+1, sp+2); }
! 237: | ROOT '(' e ',' e ')' { sp--; CHECK_UI ("Nth-root", sp+1);
! 238: mpz_root (sp, sp, mpz_get_ui (sp+1)); }
! 239: | SQRT '(' e ')' { mpz_sqrt (sp, sp); }
! 240:
! 241: | VARIABLE {
! 242: sp++;
! 243: CHECK_OVERFLOW ();
! 244: CHECK_VARIABLE ($1);
! 245: mpz_set (sp, variable[$1]);
! 246: }
! 247: | NUMBER {
! 248: sp++;
! 249: CHECK_OVERFLOW ();
! 250: if (mpz_set_str (sp, $1, ibase) != 0)
! 251: {
! 252: fprintf (stderr, "Invalid number: %s\n", $1);
! 253: YYERROR;
! 254: }
! 255: };
! 256:
! 257: gcdlist:
! 258: e /* value on stack */
! 259: | gcdlist ',' e { sp--; mpz_gcd (sp, sp, sp+1); };
! 260:
! 261: lcmlist:
! 262: e /* value on stack */
! 263: | lcmlist ',' e { sp--; mpz_lcm (sp, sp, sp+1); };
! 264:
! 265: %%
! 266:
! 267: yyerror (char *s)
! 268: {
! 269: fprintf (stderr, "%s\n", s);
! 270: }
! 271:
! 272: int calc_option_readline = -1;
! 273:
! 274: int
! 275: main (int argc, char *argv[])
! 276: {
! 277: int i;
! 278:
! 279: for (i = 1; i < argc; i++)
! 280: {
! 281: if (strcmp (argv[i], "--readline") == 0)
! 282: calc_option_readline = 1;
! 283: else if (strcmp (argv[i], "--noreadline") == 0)
! 284: calc_option_readline = 0;
! 285: else if (strcmp (argv[i], "--help") == 0)
! 286: {
! 287: printf ("Usage: calc [--option]...\n");
! 288: printf (" --readline use readline\n");
! 289: printf (" --noreadline don't use readline\n");
! 290: printf (" --help this message\n");
! 291: printf ("Readline is only available when compiled in,\n");
! 292: printf ("and in that case it's the default on a tty.\n");
! 293: exit (0);
! 294: }
! 295: else
! 296: {
! 297: fprintf (stderr, "Unrecognised option: %s\n", argv[i]);
! 298: exit (1);
! 299: }
! 300: }
! 301:
! 302: #if WITH_READLINE
! 303: calc_init_readline ();
! 304: #else
! 305: if (calc_option_readline == 1)
! 306: {
! 307: fprintf (stderr, "Readline support not available\n");
! 308: exit (1);
! 309: }
! 310: #endif
! 311:
! 312: for (i = 0; i < numberof (variable); i++)
! 313: mpz_init (variable[i]);
! 314:
! 315: for (i = 0; i < numberof (stack); i++)
! 316: mpz_init (stack[i]);
! 317:
! 318: return yyparse ();
! 319: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to calc.y CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / demos / calc