1 #include <glib.h>
2 #include <string.h>
3 #include <stdlib.h>
4 #include <stdio.h>
5
6 #include "parser.h"
7 #include "parserfunc.h"
8
9 /* Register error variables in ParserState structure. */
10 void
set_error(ParserState * state,gint errorno,const gchar * token)11 set_error(ParserState* state, gint errorno, const gchar *token)
12 {
13 state->error = errorno;
14 if(token)
15 state->error_token = strdup(token);
16 }
17
18 /* Unused function pointer. This won't be called anytime. */
19 void*
pf_none(ParseNode * self)20 pf_none(ParseNode* self)
21 {
22 return NULL;
23 }
24
25 /* Set variable. */
26 void*
pf_set_var(ParseNode * self)27 pf_set_var(ParseNode* self)
28 {
29 MPNumber* val;
30 val = (MPNumber *) (*(self->right->evaluate))(self->right);
31 if(!val || !(self->state->set_variable))
32 {
33 if(val)
34 mp_free(val);
35 return NULL;
36 }
37 (*(self->state->set_variable))(self->state, self->left->token->string, val);
38 return val;
39 }
40
41 /* Converts Number from one unit to other. */
42 void*
pf_convert_number(ParseNode * self)43 pf_convert_number(ParseNode* self)
44 {
45 gchar* from;
46 gchar* to;
47 gint free_from = 0;
48 gint free_to = 0;
49 MPNumber tmp = mp_new();
50 MPNumber* ans = mp_new_ptr();
51 if(self->left->value)
52 {
53 from = (gchar*) self->left->value;
54 free_from = 1;
55 }
56 else
57 from = self->left->token->string;
58 if(self->right->value)
59 {
60 to = (gchar*) self->right->value;
61 free_to = 1;
62 }
63 else
64 to = self->right->token->string;
65
66 if(mp_set_from_string(self->left->left->token->string, self->state->options->base, &tmp) != 0)
67 {
68 mp_free(ans);
69 ans = NULL;
70 goto END_PF_CONVERT_NUMBER;
71 }
72 if(!(self->state->convert))
73 {
74 mp_free(ans);
75 ans = NULL;
76 goto END_PF_CONVERT_NUMBER;
77 }
78 if(!(*(self->state->convert))(self->state, &tmp, from, to, ans))
79 {
80 set_error(self->state, PARSER_ERR_UNKNOWN_CONVERSION, NULL);
81 mp_free(ans);
82 ans = NULL;
83 }
84 END_PF_CONVERT_NUMBER:
85 if(free_from)
86 {
87 g_free(self->left->value);
88 self->left->value = NULL;
89 }
90 if(free_to)
91 {
92 g_free(self->right->value);
93 self->right->value = NULL;
94 }
95 mp_clear(&tmp);
96 return ans;
97 }
98
99 /* Conversion rate. */
100 void*
pf_convert_1(ParseNode * self)101 pf_convert_1(ParseNode* self )
102 {
103 gchar* from;
104 gchar* to;
105 gint free_from = 0;
106 gint free_to = 0;
107 MPNumber tmp = mp_new();
108 MPNumber* ans = mp_new_ptr();
109 if(self->left->value)
110 {
111 from = (gchar*) self->left->value;
112 free_from = 1;
113 }
114 else
115 from = self->left->token->string;
116 if(self->right->value)
117 {
118 to = (gchar*) self->right->value;
119 free_to = 1;
120 }
121 else
122 to = self->right->token->string;
123 mp_set_from_integer(1, &tmp);
124 if(!(self->state->convert))
125 {
126 mp_free(ans);
127 return NULL;
128 }
129 if(!(*(self->state->convert))(self->state, &tmp, from, to, ans))
130 {
131 set_error(self->state, PARSER_ERR_UNKNOWN_CONVERSION, NULL);
132 mp_free(ans);
133 ans = NULL;
134 }
135 if(free_from)
136 {
137 g_free(self->left->value);
138 self->left->value = NULL;
139 }
140 if(free_to)
141 {
142 g_free(self->right->value);
143 self->right->value = NULL;
144 }
145 mp_clear(&tmp);
146 return ans;
147 }
148
149 /* Join source unit and power. */
150 gchar*
pf_make_unit(gchar * source,gchar * power)151 pf_make_unit(gchar* source, gchar* power)
152 {
153 return g_strjoin(NULL, source, power, NULL);
154 }
155
156 static gchar *
utf8_next_char(const gchar * c)157 utf8_next_char(const gchar *c)
158 {
159 c++;
160 while((*c & 0xC0) == 0x80)
161 c++;
162 return(gchar *) c;
163 }
164
165 /* Get value of variable. */
166 void*
pf_get_variable(ParseNode * self)167 pf_get_variable(ParseNode* self)
168 {
169 gint result = 0;
170
171 const gchar *c, *next;
172 gchar *buffer;
173 MPNumber value = mp_new();
174
175 MPNumber t = mp_new();
176 MPNumber* ans = mp_new_ptr();
177
178 if(!(self->state->get_variable))
179 {
180 free(ans);
181 return NULL;
182 }
183
184 /* If defined, then get the variable */
185 if((*(self->state->get_variable))(self->state, self->token->string, ans))
186 {
187 return ans;
188 }
189
190 /* If has more than one character then assume a multiplication of variables */
191 if(utf8_next_char(self->token->string)[0] != '\0')
192 {
193 result = 1;
194 buffer = (gchar*) malloc(sizeof(gchar) * strlen(self->token->string));
195 mp_set_from_integer(1, &value);
196 for(c = self->token->string; *c != '\0'; c = next)
197 {
198 next = utf8_next_char(c);
199 snprintf(buffer, next - c + 1, "%s", c);
200 if(!(*(self->state->get_variable))(self->state, buffer, &t))
201 {
202 result = 0;
203 break;
204 }
205 mp_multiply(&value, &t, &value);
206 }
207 free(buffer);
208 if(result)
209 mp_set_from_mp(&value, ans);
210 }
211 if(!result)
212 {
213 free (ans);
214 ans = NULL;
215 set_error(self->state, PARSER_ERR_UNKNOWN_VARIABLE, self->token->string);
216 }
217 return ans;
218 }
219
220 /* Get value of variable with power. */
221 void*
pf_get_variable_with_power(ParseNode * self)222 pf_get_variable_with_power(ParseNode* self)
223 {
224 gint result = 0;
225 gint pow;
226
227 const gchar *c, *next;
228 gchar *buffer;
229 MPNumber value = mp_new();
230
231 MPNumber t = mp_new();
232 MPNumber* ans = mp_new_ptr();
233 pow = super_atoi(((LexerToken*) self->value)->string);
234
235 /* No need to free the memory. It is allocated and freed somewhere else. */
236 self->value = NULL;
237
238 if(!(self->state->get_variable))
239 {
240 free(ans);
241 return NULL;
242 }
243
244 /* If defined, then get the variable */
245 if((*(self->state->get_variable))(self->state, self->token->string, ans))
246 {
247 mp_xpowy_integer(ans, pow, ans);
248 return ans;
249 }
250
251 /* If has more than one character then assume a multiplication of variables */
252 if(utf8_next_char(self->token->string)[0] != '\0')
253 {
254 result = 1;
255 buffer = (gchar*) malloc(sizeof(gchar) * strlen(self->token->string));
256 mp_set_from_integer(1, &value);
257 for(c = self->token->string; *c != '\0'; c = next)
258 {
259 next = utf8_next_char(c);
260 snprintf(buffer, next - c + 1, "%s", c);
261 if(!(*(self->state->get_variable))(self->state, buffer, &t))
262 {
263 result = 0;
264 break;
265 }
266
267 /* If last term do power */
268 if(*next == '\0')
269 mp_xpowy_integer(&t, pow, &t);
270 mp_multiply(&value, &t, &value);
271 }
272 free(buffer);
273 if(result)
274 mp_set_from_mp(&value, ans);
275 }
276 if(!result)
277 {
278 free(ans);
279 ans = NULL;
280 set_error(self->state, PARSER_ERR_UNKNOWN_VARIABLE, self->token->string);
281 }
282 return ans;
283 }
284
285 /* Apply function on child. */
286 void*
pf_apply_func(ParseNode * self)287 pf_apply_func(ParseNode* self)
288 {
289 MPNumber* val;
290 MPNumber* ans = mp_new_ptr();
291 val = (MPNumber*) (*(self->right->evaluate))(self->right);
292 if(!(self->state->get_function))
293 {
294 free(val);
295 free(ans);
296 return NULL;
297 }
298 if(!val)
299 {
300 free(ans);
301 return NULL;
302 }
303 if(!(*(self->state->get_function))(self->state, self->token->string, val, ans))
304 {
305 free(val);
306 free(ans);
307 set_error(self->state, PARSER_ERR_UNKNOWN_FUNCTION, self->token->string);
308 return NULL;
309 }
310 free(val);
311 return ans;
312 }
313
314 /* Apply function with +ve power. */
315 void*
pf_apply_func_with_power(ParseNode * self)316 pf_apply_func_with_power(ParseNode* self)
317 {
318 MPNumber* val;
319 MPNumber* tmp = mp_new_ptr();
320 MPNumber* ans = mp_new_ptr();
321 gint pow;
322 val = (MPNumber*) (*(self->right->evaluate))(self->right);
323 if(!(self->state->get_function))
324 {
325 mp_free(tmp);
326 mp_free(ans);
327 mp_free(val);
328 self->value = NULL;
329 return NULL;
330 }
331 if(!val)
332 {
333 mp_free(tmp);
334 mp_free(ans);
335 self->value = NULL;
336 return NULL;
337 }
338 if(!(*(self->state->get_function))(self->state, self->token->string, val, tmp))
339 {
340 mp_free(tmp);
341 mp_free(ans);
342 mp_free(val);
343 self->value = NULL;
344 set_error(self->state, PARSER_ERR_UNKNOWN_FUNCTION, self->token->string);
345 return NULL;
346 }
347 pow = super_atoi(((LexerToken*) self->value)->string);
348 mp_xpowy_integer(tmp, pow, ans);
349 mp_free(val);
350 mp_free(tmp);
351 self->value = NULL;
352 return ans;
353 }
354
355 /* Apply function with -ve power. */
356 void*
pf_apply_func_with_npower(ParseNode * self)357 pf_apply_func_with_npower(ParseNode* self)
358 {
359 MPNumber* val;
360 MPNumber* tmp = mp_new_ptr();
361 MPNumber* ans = mp_new_ptr();
362 gint pow;
363 gchar* inv_name;
364 inv_name = (gchar*) malloc(sizeof(gchar) * strlen(self->token->string) + strlen("⁻¹") + 1);
365 strcpy(inv_name, self->token->string);
366 strcat(inv_name, "⁻¹");
367 val = (MPNumber*) (*(self->right->evaluate))(self->right);
368 if(!val)
369 {
370 mp_free(tmp);
371 free(inv_name);
372 mp_free(ans);
373 self->value = NULL;
374 return NULL;
375 }
376 if(!(self->state->get_function))
377 {
378 mp_free(tmp);
379 mp_free(ans);
380 free(inv_name);
381 self->value = NULL;
382 return NULL;
383 }
384 if(!(*(self->state->get_function))(self->state, inv_name, val, tmp))
385 {
386 mp_free(tmp);
387 mp_free(ans);
388 mp_free(val);
389 free(inv_name);
390 self->value = NULL;
391 set_error(self->state, PARSER_ERR_UNKNOWN_FUNCTION, self->token->string);
392 return NULL;
393 }
394 pow = super_atoi(((LexerToken*) self->value)->string);
395 mp_xpowy_integer(tmp, -pow, ans);
396 mp_free(val);
397 mp_free(tmp);
398 free(inv_name);
399 self->value = NULL;
400 return ans;
401 }
402
403 /* Find nth root of child. */
404 void*
pf_do_nth_root(ParseNode * self)405 pf_do_nth_root(ParseNode* self)
406 {
407 MPNumber* val;
408 gint pow;
409 MPNumber* ans = mp_new_ptr();
410 pow = sub_atoi(((LexerToken*) self->value)->string);
411 self->value = NULL;
412 val = (MPNumber*) (*(self->right->evaluate))(self->right);
413 if(!val)
414 {
415 mp_free(ans);
416 return NULL;
417 }
418 mp_root(val, pow, ans);
419 mp_free(val);
420 return ans;
421 }
422
423 /* Find sqrt of child. */
424 void*
pf_do_sqrt(ParseNode * self)425 pf_do_sqrt(ParseNode* self)
426 {
427 MPNumber* val;
428 MPNumber* ans = mp_new_ptr();
429 val = (MPNumber*) (*(self->right->evaluate))(self->right);
430 if(!val)
431 {
432 free(ans);
433 return NULL;
434 }
435 mp_sqrt(val, ans);
436 free(val);
437 return ans;
438 }
439
440 /* Find 3rd root of child. */
441 void*
pf_do_root_3(ParseNode * self)442 pf_do_root_3(ParseNode* self)
443 {
444 MPNumber* val;
445 MPNumber* ans = mp_new_ptr();
446 val = (MPNumber*) (*(self->right->evaluate))(self->right);
447 if(!val)
448 {
449 mp_free(ans);
450 return NULL;
451 }
452 mp_root(val, 3, ans);
453 mp_free(val);
454 return ans;
455 }
456
457 /* Find 4th root of child. */
458 void*
pf_do_root_4(ParseNode * self)459 pf_do_root_4(ParseNode* self)
460 {
461 MPNumber* val;
462 MPNumber* ans = mp_new_ptr();
463 val = (MPNumber*) (*(self->right->evaluate))(self->right);
464 if(!val)
465 {
466 mp_free(ans);
467 return NULL;
468 }
469 mp_root(val, 4, ans);
470 mp_free(val);
471 return ans;
472 }
473
474 /* Apply floor function. */
475 void*
pf_do_floor(ParseNode * self)476 pf_do_floor(ParseNode* self)
477 {
478 MPNumber* val;
479 MPNumber* ans = mp_new_ptr();
480 val = (MPNumber*) (*(self->right->evaluate))(self->right);
481 if(!val)
482 {
483 mp_free(ans);
484 return NULL;
485 }
486 mp_floor(val, ans);
487 mp_free(val);
488 return ans;
489 }
490
491 /* Apply ceiling function. */
pf_do_ceiling(ParseNode * self)492 void* pf_do_ceiling (ParseNode* self)
493 {
494 MPNumber* val;
495 MPNumber* ans = mp_new_ptr();
496 val = (MPNumber*) (*(self->right->evaluate))(self->right);
497 if(!val)
498 {
499 mp_free(ans);
500 return NULL;
501 }
502 mp_ceiling(val, ans);
503 mp_free(val);
504 return ans;
505 }
506
507 /* Round off. */
508 void*
pf_do_round(ParseNode * self)509 pf_do_round(ParseNode* self)
510 {
511 MPNumber* val;
512 MPNumber* ans = mp_new_ptr();
513 val = (MPNumber*) (*(self->right->evaluate))(self->right);
514 if(!val)
515 {
516 mp_free(ans);
517 return NULL;
518 }
519 mp_round(val, ans);
520 mp_free(val);
521 return ans;
522 }
523
524 /* Fraction. */
525 void*
pf_do_fraction(ParseNode * self)526 pf_do_fraction(ParseNode* self)
527 {
528 MPNumber* val;
529 MPNumber* ans = mp_new_ptr();
530 val = (MPNumber*) (*(self->right->evaluate))(self->right);
531 if(!val)
532 {
533 mp_free(ans);
534 return NULL;
535 }
536 mp_fractional_part(val, ans);
537 mp_free(val);
538 return ans;
539 }
540
541 /* Absolute value. */
542 void*
pf_do_abs(ParseNode * self)543 pf_do_abs(ParseNode* self)
544 {
545 MPNumber* val;
546 MPNumber* ans = mp_new_ptr();
547 val = (MPNumber*) (*(self->right->evaluate))(self->right);
548 if(!val)
549 {
550 mp_free(ans);
551 return NULL;
552 }
553 mp_abs(val, ans);
554 mp_free(val);
555 return ans;
556 }
557
558 /* Find x^y for x and y being MPNumber. */
559 void*
pf_do_x_pow_y(ParseNode * self)560 pf_do_x_pow_y(ParseNode* self)
561 {
562 MPNumber* val;
563 MPNumber* pow;
564 MPNumber* ans = mp_new_ptr();
565 val = (MPNumber*) (*(self->left->evaluate))(self->left);
566 pow = (MPNumber*) (*(self->right->evaluate))(self->right);
567 if(!val || !pow)
568 {
569 if(val)
570 mp_free(val);
571 if(pow)
572 mp_free(pow);
573 mp_free(ans);
574 return NULL;
575 }
576 mp_xpowy(val, pow, ans);
577 mp_free(val);
578 mp_free(pow);
579 return ans;
580 }
581
582 /* Find x^y for MPNumber x and integer y. */
583 void*
pf_do_x_pow_y_int(ParseNode * self)584 pf_do_x_pow_y_int(ParseNode* self)
585 {
586 MPNumber* val;
587 long pow;
588 MPNumber* ans = mp_new_ptr();
589 val = (MPNumber*) (*(self->left->evaluate))(self->left);
590
591 if(!val)
592 {
593 val = mp_new_ptr();
594 mp_set_from_integer(super_atoi(self->left->token->string), val);
595 }
596
597 if (self->right->token != NULL)
598 {
599 pow = super_atoi(self->right->token->string);
600 }
601 else
602 {
603 MPNumber* aux = (MPNumber*) (*(self->right->evaluate))(self->right);
604 pow = mp_to_integer(aux);
605 mp_free(aux);
606 }
607
608 if(!val)
609 {
610 mp_free(ans);
611 return NULL;
612 }
613 mp_xpowy_integer(val, pow, ans);
614 mp_free(val);
615 return ans;
616 }
617
618 /* Find factorial. */
619 void*
pf_do_factorial(ParseNode * self)620 pf_do_factorial(ParseNode* self)
621 {
622 MPNumber* val;
623 MPNumber* ans = mp_new_ptr();
624 val = (MPNumber*) (*(self->right->evaluate))(self->right);
625 if(!val)
626 {
627 mp_free(ans);
628 return NULL;
629 }
630 mp_factorial(val, ans);
631 mp_free(val);
632 return ans;
633 }
634
635 /* Apply unary minus. */
636 void*
pf_unary_minus(ParseNode * self)637 pf_unary_minus(ParseNode* self)
638 {
639 MPNumber* val;
640 MPNumber* ans = mp_new_ptr();
641 val = (MPNumber*) (*(self->right->evaluate))(self->right);
642 if(!val)
643 {
644 mp_free(ans);
645 return NULL;
646 }
647 mp_invert_sign(val, ans);
648 mp_free(val);
649 return ans;
650 }
651
652 /* Divide. */
653 void*
pf_do_divide(ParseNode * self)654 pf_do_divide(ParseNode* self)
655 {
656 MPNumber* left;
657 MPNumber* right;
658 MPNumber* ans = mp_new_ptr();
659 left = (MPNumber*) (*(self->left->evaluate))(self->left);
660 right = (MPNumber*) (*(self->right->evaluate))(self->right);
661 if(!left || !right)
662 {
663 if(left)
664 mp_free(left);
665 if(right)
666 mp_free(right);
667 mp_free(ans);
668 return NULL;
669 }
670 mp_divide(left, right, ans);
671 mp_free(left);
672 mp_free(right);
673 return ans;
674 }
675
676 /* Modulus. */
677 void*
pf_do_mod(ParseNode * self)678 pf_do_mod(ParseNode* self)
679 {
680 MPNumber* left;
681 MPNumber* right;
682 MPNumber* ans = mp_new_ptr();
683 left = (MPNumber*) (*(self->left->evaluate))(self->left);
684 right = (MPNumber*) (*(self->right->evaluate))(self->right);
685 if(!left || !right)
686 {
687 if(left)
688 mp_free(left);
689 if(right)
690 mp_free(right);
691 mp_free(ans);
692 return NULL;
693 }
694 if (self->left->evaluate == pf_do_x_pow_y)
695 {
696 MPNumber* base_value = (MPNumber*) (*(self->left->left->evaluate))(self->left->left);
697 MPNumber* exponent = (MPNumber*) (*(self->left->right->evaluate))(self->left->right);
698 if(!base_value || !exponent)
699 {
700 if(base_value)
701 mp_free(base_value);
702 if(exponent)
703 mp_free(exponent);
704 mp_free(ans);
705 return NULL;
706 }
707 mp_modular_exponentiation(base_value, exponent, right, ans);
708 mp_free(base_value);
709 mp_free(exponent);
710 }
711 else
712 mp_modulus_divide(left, right, ans);
713
714 mp_free(left);
715 mp_free(right);
716 return ans;
717 }
718
719 /* Multiply two numbers. */
720 void*
pf_do_multiply(ParseNode * self)721 pf_do_multiply(ParseNode* self)
722 {
723 MPNumber* left;
724 MPNumber* right;
725 MPNumber* ans = mp_new_ptr();
726 left = (MPNumber*) (*(self->left->evaluate))(self->left);
727 right = (MPNumber*) (*(self->right->evaluate))(self->right);
728 if(!left || !right)
729 {
730 if(left)
731 mp_free(left);
732 if(right)
733 mp_free(right);
734 mp_free(ans);
735 return NULL;
736 }
737 mp_multiply(left, right, ans);
738 mp_free(left);
739 mp_free(right);
740 return ans;
741 }
742
743 /* Subtract two numbers. */
744 void*
pf_do_subtract(ParseNode * self)745 pf_do_subtract(ParseNode* self)
746 {
747 MPNumber* left;
748 MPNumber* right;
749 MPNumber* ans = mp_new_ptr();
750 left = (MPNumber*) (*(self->left->evaluate))(self->left);
751 right = (MPNumber*) (*(self->right->evaluate))(self->right);
752 if(!left || !right)
753 {
754 if(left)
755 mp_free(left);
756 if(right)
757 mp_free(right);
758 free(ans);
759 return NULL;
760 }
761 mp_subtract(left, right, ans);
762 mp_free(left);
763 mp_free(right);
764 return ans;
765 }
766
767 /* Add two numbers. */
768 void*
pf_do_add(ParseNode * self)769 pf_do_add(ParseNode* self)
770 {
771 MPNumber* left;
772 MPNumber* right;
773 MPNumber* ans = mp_new_ptr();
774 left = (MPNumber*) (*(self->left->evaluate))(self->left);
775 right = (MPNumber*) (*(self->right->evaluate))(self->right);
776 if(!left || !right)
777 {
778 if(left)
779 mp_free(left);
780 if(right)
781 mp_free(right);
782 free(ans);
783 return NULL;
784 }
785 mp_add(left, right, ans);
786 mp_free(left);
787 mp_free(right);
788 return ans;
789 }
790
791 /* Add (x) Percentage to value. */
792 void*
pf_do_add_percent(ParseNode * self)793 pf_do_add_percent(ParseNode* self)
794 {
795 MPNumber* ans = mp_new_ptr();
796 MPNumber* val;
797 MPNumber* per;
798 val = (MPNumber*) (*(self->left->evaluate))(self->left);
799 per = (MPNumber*) (*(self->right->evaluate))(self->right);
800 if(!val || !per)
801 {
802 if(val)
803 mp_free(val);
804 if(per)
805 mp_free(per);
806 mp_free(ans);
807 return NULL;
808 }
809 mp_add_integer(per, 100, per);
810 mp_divide_integer(per, 100, per);
811 mp_multiply(val, per, ans);
812 mp_free(val);
813 mp_free(per);
814 return ans;
815 }
816
817 /* Subtract (x) Percentage to value. */
818 void*
pf_do_subtract_percent(ParseNode * self)819 pf_do_subtract_percent(ParseNode* self)
820 {
821 MPNumber* ans = mp_new_ptr();
822 MPNumber* val;
823 MPNumber* per;
824 val = (MPNumber*) (*(self->left->evaluate))(self->left);
825 per = (MPNumber*) (*(self->right->evaluate))(self->right);
826 if(!val || !per)
827 {
828 if(val)
829 mp_free(val);
830 if(per)
831 mp_free(per);
832 free(ans);
833 return NULL;
834 }
835 mp_add_integer(per, -100, per);
836 mp_divide_integer(per, -100, per);
837 mp_multiply(val, per, ans);
838 mp_free(val);
839 mp_free(per);
840 return ans;
841 }
842
843 /* Converts a constant into percentage. */
844 void*
pf_do_percent(ParseNode * self)845 pf_do_percent(ParseNode* self)
846 {
847 MPNumber* val;
848 MPNumber* ans = mp_new_ptr();
849 val = (MPNumber*) (*(self->right->evaluate))(self->right);
850 if(!val)
851 {
852 mp_free(ans);
853 return NULL;
854 }
855 mp_divide_integer(val, 100, ans);
856 mp_free(val);
857 return ans;
858 }
859
860 /* NOT. */
861 void*
pf_do_not(ParseNode * self)862 pf_do_not(ParseNode* self)
863 {
864 MPNumber* val;
865 MPNumber* ans = mp_new_ptr();
866 val = (MPNumber*) (*(self->right->evaluate))(self->right);
867 if(!val)
868 {
869 mp_free(ans);
870 return NULL;
871 }
872 if(!mp_is_overflow(val, self->state->options->wordlen))
873 {
874 set_error(self->state, PARSER_ERR_OVERFLOW, NULL);
875 mp_free(ans);
876 mp_free(val);
877 return NULL;
878 }
879 mp_not(val, self->state->options->wordlen, ans);
880 mp_free(val);
881 return ans;
882 }
883
884 /* AND. */
885 void*
pf_do_and(ParseNode * self)886 pf_do_and(ParseNode* self)
887 {
888 MPNumber* left;
889 MPNumber* right;
890 MPNumber* ans = mp_new_ptr();
891 left = (MPNumber*) (*(self->left->evaluate))(self->left);
892 right = (MPNumber*) (*(self->right->evaluate))(self->right);
893 if(!left || !right)
894 {
895 if(left)
896 mp_free(left);
897 if(right)
898 mp_free(right);
899 mp_free(ans);
900 return NULL;
901 }
902 mp_and(left, right, ans);
903 mp_free(left);
904 mp_free(right);
905 return ans;
906 }
907
908 /* OR. */
909 void*
pf_do_or(ParseNode * self)910 pf_do_or(ParseNode* self)
911 {
912 MPNumber* left;
913 MPNumber* right;
914 MPNumber* ans = mp_new_ptr();
915 left = (MPNumber*) (*(self->left->evaluate))(self->left);
916 right = (MPNumber*) (*(self->right->evaluate))(self->right);
917 if(!left || !right)
918 {
919 if(left)
920 mp_free(left);
921 if(right)
922 mp_free(right);
923 mp_free(ans);
924 return NULL;
925 }
926 mp_or(left, right, ans);
927 mp_free(left);
928 mp_free(right);
929 return ans;
930 }
931
932 /* XOR. */
933 void*
pf_do_xor(ParseNode * self)934 pf_do_xor(ParseNode* self)
935 {
936 MPNumber* left;
937 MPNumber* right;
938 MPNumber* ans = mp_new_ptr();
939 left = (MPNumber*) (*(self->left->evaluate))(self->left);
940 right = (MPNumber*) (*(self->right->evaluate))(self->right);
941 if(!left || !right)
942 {
943 if(left)
944 mp_free(left);
945 if(right)
946 mp_free(right);
947 free(ans);
948 return NULL;
949 }
950 mp_xor(left, right, ans);
951 mp_free(left);
952 mp_free(right);
953 return ans;
954 }
955
956 /* Constant value. Convert into MPNumber and return. */
957 void*
pf_constant(ParseNode * self)958 pf_constant(ParseNode* self)
959 {
960 MPNumber* ans = mp_new_ptr();
961 if(mp_set_from_string(self->token->string, self->state->options->base, ans) != 0)
962 {
963 /* This should never happen, as l_check_if_number() has already passed the string once. */
964 /* If the code reaches this point, something is really wrong. X( */
965 mp_free(ans);
966 set_error(self->state, PARSER_ERR_INVALID, self->token->string);
967 return NULL;
968 }
969 return ans;
970 }
971
972