Fruit's git repositories f00f / arglozer calc.g
arglozer

Tree @arglozer (Download .tar.gz)

calc.g @arglozer — raw · history · blame 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
%include {
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <math.h>
	#include "f00f.h"
}
%type expr {real}
%type calc {real}
%token_type {byte*}
%start_symbol calc
%left BOR.
%left BXOR.
%left BAND.
%left BSHL BSHR.
%left PLUS MINUS.
%left TIMES DIV MOD.
%left POW SQUARE CUBIC IDENTITY INVERT.
%left DICE.
%left BNOT.
%left FACT.
%name calcParse
%extra_argument {calcState_t *calcState}
%parse_failure {calcState->success = FALSE;}

calc(X) ::= expr(A). { if(calcState->success) calcState->result = vorige.echt = X = A; }

expr(X) ::= MINUS expr(A). { X = -A; }
expr(X) ::= PLUS expr(A). { X = A; }
expr(X) ::= expr(A) FACT. { X = fact(A); }
expr(X) ::= expr(A) INVERT. { X = 1.0/A; }
expr(X) ::= expr(A) IDENTITY. { X = A; }
expr(X) ::= expr(A) SQUARE. { X = A*A; }
expr(X) ::= expr(A) CUBIC. { X = A*A*A; }
expr(X) ::= ONEQUARTER. { X = 0.25; }
expr(X) ::= ONEHALF. { X = 0.5; }
expr(X) ::= THREEQUARTERS. { X = 0.75; }
expr(X) ::= expr(A) DICE expr(B). { X = realdice(B, A); }
expr(X) ::= DICE expr(A). { X = realdice(A, 1); }

expr(X) ::= expr(A) MINUS expr(B). { X = A - B; }
expr(X) ::= expr(A) PLUS expr(B). { X = A + B; }
expr(X) ::= expr(A) TIMES expr(B). { X = A * B; }
expr(X) ::= expr(A) DIV expr(B). { X = A / B; }
expr(X) ::= expr(A) MOD expr(B). { X = fmod(A, B); }
expr(X) ::= expr(A) POW expr(B). { X = B==0.0?A==0.0?0.0/0.0:1.0:pow(A, B); }

expr(X) ::= expr(A) BSHL expr(B). { X = A * pow(2.0, B); }
expr(X) ::= expr(A) BSHR expr(B). { X = A / pow(2.0, B); }
expr(X) ::= expr(A) BOR expr(B). { X = (long long int)A | (long long int)B; }
expr(X) ::= expr(A) BAND expr(B). { X = (long long int)A & (long long int)B; }
expr(X) ::= expr(A) BXOR expr(B). { X = (long long int)A ^ (long long int)B; }
expr(X) ::= BNOT expr(A). { X = ~(long long int)A; }

expr(X) ::= ACOS LPAREN expr(A) RPAREN. { X = acos(A); }
expr(X) ::= ASIN LPAREN expr(A) RPAREN. { X = asin(A); }
expr(X) ::= ATAN LPAREN expr(A) RPAREN. { X = atan(A); }
expr(X) ::= ATAN2 LPAREN expr(A) COMMA expr(B) RPAREN. { X = atan2(A, B); }
expr(X) ::= COSH LPAREN expr(A) RPAREN. { X = cosh(A); }
expr(X) ::= SINH LPAREN expr(A) RPAREN. { X = sinh(A); }
expr(X) ::= TANH LPAREN expr(A) RPAREN. { X = tanh(A); }
expr(X) ::= COS LPAREN expr(A) RPAREN. { X = cos(A); }
expr(X) ::= SIN LPAREN expr(A) RPAREN. { X = sin(A); }
expr(X) ::= TAN LPAREN expr(A) RPAREN. { X = tan(A); }
expr(X) ::= ABS LPAREN expr(A) RPAREN. { X = A>0?A:-A; }
expr(X) ::= GCD LPAREN expr(A) COMMA expr(B) RPAREN. { X = gcd(A, B); }
expr(X) ::= LCM LPAREN expr(A) COMMA expr(B) RPAREN. { X = lcm(A, B); }

expr(X) ::= ERF LPAREN expr(A) RPAREN. { X = erf(A); }
expr(X) ::= ERFC LPAREN expr(A) RPAREN. { X = erfc(A); }
expr(X) ::= GAMMA LPAREN expr(A) RPAREN. { X = gamma(A); }
expr(X) ::= LGAMMA LPAREN expr(A) RPAREN. { X = lgamma(A); }

expr(X) ::= EXP LPAREN expr(A) RPAREN. { X = exp(A); }
expr(X) ::= LOG LPAREN expr(A) RPAREN. { X = log10(A); }
expr(X) ::= LN LPAREN expr(A) RPAREN. { X = log(A); }
expr(X) ::= LG LPAREN expr(A) RPAREN. { X = log(A)/M_LN2; }
expr(X) ::= SQRT LPAREN expr(A) RPAREN. { X = sqrt(A); }

expr(X) ::= EURO LPAREN expr(A) RPAREN. { X = A / 2.20371; }
expr(X) ::= GULDEN LPAREN expr(A) RPAREN. { X = A * 2.20371; }
expr(X) ::= F2C LPAREN expr(A) RPAREN. { X = (A-32.0)/9.0*5.0; }
expr(X) ::= C2F LPAREN expr(A) RPAREN. { X = A/5.0*9.0+32.0; }

expr(X) ::= C_PI. { X = M_PI; }
expr(X) ::= C_E. { X = M_E; }
expr(X) ::= ANS. { X = vorige.echt; }

expr(X) ::= LPAREN expr(A) RPAREN. { X = A; }

expr(X) ::= REAL(A). { sscanf(A, "%Lf", &(X)); }
expr(X) ::= INTEGER(A). { X = (real)strtoll(A, NULL, 0); }

expr ::= CALC_DUMMY_CHARACTER CALC_UNKNOWN_CHARACTER.