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