Debian Codegraph @

modules/lsp-runtime-lib/src/main/expr/parser.cpp

raw
1 /*
2 * Copyright (C) 2025 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2025 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 18 сент. 2019 г.
7 *
8 * lsp-runtime-lib 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 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/expr/parser.h>
23 #include <lsp-plug.in/lltl/parray.h>
24 #include <lsp-plug.in/stdlib/math.h>
25
26 namespace lsp
27 {
28 namespace expr
29 {
30 void parse_destroy(expr_t *expr)
31 {
32 if (expr == NULL)
33 return;
34
35 expr->eval = NULL;
36 switch (expr->type)
37 {
38 case ET_VALUE:
39 if (expr->value.type == VT_STRING)
40 {
41 delete expr->value.v_str;
42 expr->value.v_str = NULL;
43 }
44 break;
45 case ET_RESOLVE:
46 if (expr->resolve.items != NULL)
47 {
48 for (size_t i=0, n=expr->resolve.count; i<n; ++i)
49 parse_destroy(expr->resolve.items[i]);
50 ::free(expr->resolve.items);
51 expr->resolve.items = NULL;
52 }
53 if (expr->resolve.name != NULL)
54 {
55 delete expr->resolve.name;
56 expr->resolve.name = NULL;
57 }
58 break;
59 case ET_CALL:
60 if (expr->call.items != NULL)
61 {
62 for (size_t i=0, n=expr->call.count; i<n; ++i)
63 parse_destroy(expr->call.items[i]);
64 ::free(expr->call.items);
65 expr->call.items = NULL;
66 }
67 if (expr->call.name != NULL)
68 {
69 delete expr->call.name;
70 expr->call.name = NULL;
71 }
72 break;
73 case ET_CALC:
74 parse_destroy(expr->calc.left);
75 expr->calc.left = NULL;
76 parse_destroy(expr->calc.right);
77 expr->calc.right = NULL;
78 parse_destroy(expr->calc.cond);
79 expr->calc.cond = NULL;
80 break;
81
82 default:
83 break;
84 }
85
86 // Free the expression
87 ::free(expr);
88 }
89
90 expr_t *parse_create_expr()
91 {
92 return reinterpret_cast<expr_t *>(::malloc(sizeof(expr_t)));
93 }
94
95 void drop_indexes(lltl::parray<expr_t> *indexes)
96 {
97 for (size_t i=0, n=indexes->size(); i<n; ++i)
98 parse_destroy(indexes->uget(i));
99 indexes->flush();
100 }
101
102 status_t parse_identifier(expr_t **expr, Tokenizer *t, size_t flags)
103 {
104 // Get identifier
105 expr_t *bind = NULL;
106 token_t tok = t->get_token(flags);
107 if ((tok != TT_IDENTIFIER) && (!(flags & TF_BAREWORD)))
108 return STATUS_BAD_TOKEN;
109
110 LSPString *id = t->text_value()->clone();
111 if (id == NULL)
112 return STATUS_NO_MEM;
113
114 // Lookup for indexes
115 lltl::parray<expr_t> indexes;
116 while ((tok = t->get_token(TF_GET | TF_XSIGN)) == TT_LQBRACE)
117 {
118 // Brace, analyze next token
119 tok = t->get_token(TF_GET);
120 if (tok == TT_BAREWORD)
121 {
122 // Store the bareword
123 LSPString *name = t->text_value()->clone();
124 if (name == NULL)
125 {
126 drop_indexes(&indexes);
127 delete id;
128 return STATUS_NO_MEM;
129 }
130
131 // Next token should be TT_RQBRACE
132 tok = t->get_token(TF_GET);
133 if (tok != TT_RQBRACE)
134 {
135 drop_indexes(&indexes);
136 delete id;
137 return STATUS_BAD_TOKEN;
138 }
139
140 // Create new expression
141 bind = parse_create_expr();
142 if (bind == NULL)
143 {
144 drop_indexes(&indexes);
145 delete name;
146 delete id;
147 return STATUS_NO_MEM;
148 }
149
150 // Simple variable get
151 bind->eval = eval_resolve;
152 bind->type = ET_RESOLVE;
153 bind->resolve.name = name;
154 bind->resolve.count = 0;
155 bind->resolve.items = NULL;
156 }
157 else
158 {
159 // Parse the expression in square brackets
160 status_t res = parse_expression(&bind, t, TF_NONE); // Token already has been taken
161 if (res != STATUS_OK)
162 {
163 drop_indexes(&indexes);
164 delete id;
165 return res;
166 }
167
168 // Next token should be TT_RQBRACE
169 tok = t->get_token(TF_NONE);
170 if (tok != TT_RQBRACE)
171 {
172 parse_destroy(bind);
173 drop_indexes(&indexes);
174 delete id;
175 return STATUS_BAD_TOKEN;
176 }
177 }
178
179 // Add binding to list of indexes
180 if (!indexes.add(bind))
181 {
182 parse_destroy(bind);
183 drop_indexes(&indexes);
184 delete id;
185 return STATUS_NO_MEM;
186 }
187 } // while
188
189 // Create expression
190 bind = parse_create_expr();
191 if (bind == NULL)
192 {
193 drop_indexes(&indexes);
194 delete id;
195 return STATUS_NO_MEM;
196 }
197
198 bind->eval = eval_resolve;
199 bind->type = ET_RESOLVE;
200 bind->resolve.name = id;
201 bind->resolve.count = indexes.size();
202 bind->resolve.items = indexes.release();
203
204 *expr = bind;
205 return STATUS_OK;
206 }
207
208 status_t parse_call(expr_t **expr, Tokenizer *t, size_t flags)
209 {
210 // Get identifier
211 token_t tok = t->get_token(flags);
212 if (tok != TT_BAREWORD)
213 return STATUS_BAD_TOKEN;
214
215 // Get function name
216 LSPString *id = t->text_value()->clone();
217 if (id == NULL)
218 return STATUS_NO_MEM;
219 lsp_finally {
220 if (id != NULL)
221 delete id;
222 };
223
224 // Require opening brace
225 tok = t->get_token(TF_GET);
226 if (tok != TT_LBRACE)
227 return (tok == TT_EOF) ? STATUS_EOF : STATUS_BAD_TOKEN;
228
229 // Parse list of arguments
230 expr_t *bind = NULL;
231 lltl::parray<expr_t> args;
232 lsp_finally {
233 for (size_t i=0, n=args.size(); i<n; ++i)
234 parse_destroy(args.uget(i));
235 args.flush();
236 };
237
238 do
239 {
240 // Parse the expression as an argument
241 status_t res = parse_expression(&bind, t, TF_GET);
242 if (res != STATUS_OK)
243 return res;
244 lsp_finally { parse_destroy(bind); };
245
246 // Next token should be TT_COMMA or TT_RBRACE
247 tok = t->get_token(TF_NONE);
248 switch (tok)
249 {
250 case TT_COMMA:
251 case TT_RBRACE:
252 if (!args.add(bind))
253 {
254 parse_destroy(bind);
255 return STATUS_NO_MEM;
256 }
257 bind = NULL;
258 break;
259
260 case TT_EOF:
261 return STATUS_EOF;
262 default:
263 return STATUS_BAD_TOKEN;
264 }
265 } while (tok != TT_RBRACE);
266
267 // Get next token for caller
268 t->get_token(TF_GET);
269
270 // Create resulting expression
271 bind = parse_create_expr();
272 if (bind == NULL)
273 return STATUS_NO_MEM;
274
275 bind->eval = eval_call;
276 bind->type = ET_CALL;
277 bind->call.name = release_ptr(id);
278 bind->call.count = args.size();
279 bind->call.items = args.release();
280
281 *expr = bind;
282 return STATUS_OK;
283 }
284
285 status_t parse_primary(expr_t **expr, Tokenizer *t, size_t flags)
286 {
287 token_t tok = t->get_token(flags);
288 switch (tok)
289 {
290 case TT_IDENTIFIER:
291 return parse_identifier(expr, t, TF_NONE);
292
293 case TT_IVALUE:
294 {
295 expr_t *bind = parse_create_expr();
296 if (bind == NULL)
297 return STATUS_NO_MEM;
298
299 ssize_t ivalue = t->int_value();
300
301 bind->eval = eval_value;
302 bind->type = ET_VALUE;
303 if (t->get_token(TF_GET | TF_XSIGN) == TT_DB)
304 {
305 bind->value.type = VT_FLOAT;
306 bind->value.v_float = exp(ivalue * M_LN10 * 0.05);
307 t->get_token(TF_GET | TF_XSIGN);
308 }
309 else
310 {
311 bind->value.type = VT_INT;
312 bind->value.v_int = ivalue;
313 }
314
315 *expr = bind;
316 break;
317 }
318
319 case TT_FVALUE:
320 {
321 expr_t *bind = parse_create_expr();
322 if (bind == NULL)
323 return STATUS_NO_MEM;
324
325 double fvalue = t->float_value();
326
327 bind->eval = eval_value;
328 bind->type = ET_VALUE;
329 bind->value.type = VT_FLOAT;
330 if (t->get_token(TF_GET | TF_XSIGN) == TT_DB)
331 {
332 bind->value.v_float = exp(fvalue * M_LN10 * 0.05);
333 t->get_token(TF_GET | TF_XSIGN);
334 }
335 else
336 bind->value.v_float = fvalue;
337
338 *expr = bind;
339 break;
340 }
341
342 case TT_STRING:
343 case TT_TRUE:
344 case TT_FALSE:
345 case TT_PI:
346 case TT_E:
347 case TT_NULL:
348 case TT_UNDEF:
349 {
350 expr_t *bind = parse_create_expr();
351 if (bind == NULL)
352 return STATUS_NO_MEM;
353
354 bind->eval = eval_value;
355 bind->type = ET_VALUE;
356 switch (tok)
357 {
358 case TT_STRING:
359 bind->value.type = VT_STRING;
360 bind->value.v_str = t->text_value()->clone();
361 if (bind->value.v_str != NULL)
362 break;
363 ::free(bind);
364 return STATUS_NO_MEM;
365 case TT_TRUE:
366 bind->value.type = VT_BOOL;
367 bind->value.v_bool = true;
368 break;
369 case TT_FALSE:
370 bind->value.type = VT_BOOL;
371 bind->value.v_bool = false;
372 break;
373 case TT_PI:
374 bind->value.type = VT_FLOAT;
375 bind->value.v_float = M_PI;
376 break;
377 case TT_E:
378 bind->value.type = VT_FLOAT;
379 bind->value.v_float = M_E;
380 break;
381 case TT_NULL:
382 bind->value.type = VT_NULL;
383 break;
384 case TT_UNDEF:
385 bind->value.type = VT_UNDEF;
386 break;
387 default:
388 break;
389 }
390
391 *expr = bind;
392 t->get_token(TF_GET | TF_XSIGN);
393
394 return STATUS_OK;
395 }
396
397 case TT_LBRACE:
398 {
399 expr_t *bind = NULL;
400 status_t res = parse_expression(&bind, t, TF_GET);
401 if (res != STATUS_OK)
402 return res;
403
404 tok = t->get_token(TF_NONE);
405 if (tok == TT_RBRACE)
406 {
407 t->get_token(TF_GET | TF_XSIGN);
408 *expr = bind;
409 return res;
410 }
411
412 parse_destroy(bind);
413 return STATUS_BAD_TOKEN;
414 }
415
416 case TT_EOF:
417 return STATUS_EOF;
418
419 default:
420 return STATUS_BAD_TOKEN;
421 }
422 return STATUS_OK;
423 }
424
425 status_t parse_func(expr_t **expr, Tokenizer *t, size_t flags)
426 {
427 // Check token
428 token_t func = t->get_token(flags);
429
430 // Parse right part
431 status_t res;
432 expr_t *right = NULL;
433
434 switch (func)
435 {
436 case TT_EX:
437 case TT_DB:
438 case TT_SUPR:
439 case TT_SLWR:
440 case TT_SLEN:
441 case TT_SREV:
442 case TT_INT:
443 case TT_FLOAT:
444 case TT_BOOL:
445 case TT_STR:
446 case TT_SIN:
447 case TT_COS:
448 case TT_TAN:
449 case TT_ASIN:
450 case TT_ACOS:
451 case TT_ATAN:
452 case TT_LOGE:
453 case TT_LOGD:
454 case TT_LOG2:
455 case TT_EXP:
456 case TT_SQRT:
457 case TT_RAD:
458 case TT_DEG:
459 case TT_ABS:
460 {
461 // Check that LBRACE is present
462 token_t tok = t->get_token(TF_GET);
463 if (tok == TT_EOF)
464 return STATUS_EOF;
465 if (tok == TT_LBRACE)
466 {
467 // Parse sub-expression
468 res = parse_expression(&right, t, TF_GET);
469 if (res == STATUS_OK)
470 {
471 // Require right brace
472 tok = t->get_token(TF_NONE);
473 if (tok != TT_RBRACE)
474 return (tok == TT_EOF) ? STATUS_EOF : STATUS_BAD_TOKEN;
475
476 // Force to get next token
477 t->get_token(TF_GET);
478 }
479 }
480 else
481 res = parse_func(&right, t, TF_NONE);
482 break;
483 }
484
485 case TT_BAREWORD:
486 return parse_call(expr, t, TF_NONE);
487
488 default:
489 return parse_primary(expr, t, TF_NONE);
490 }
491 if (res != STATUS_OK)
492 return res;
493
494 // Create binding between left and right
495 expr_t *bind = parse_create_expr();
496 if (bind == NULL)
497 {
498 parse_destroy(right);
499 return STATUS_NO_MEM;
500 }
501 switch (func)
502 {
503 case TT_EX: bind->eval = eval_exists; break;
504 case TT_DB: bind->eval = eval_db; break;
505 case TT_SUPR: bind->eval = eval_strupper; break;
506 case TT_SLWR: bind->eval = eval_strlower; break;
507 case TT_SLEN: bind->eval = eval_strlen; break;
508 case TT_SREV: bind->eval = eval_strrev; break;
509 case TT_INT: bind->eval = eval_int_cast; break;
510 case TT_FLOAT: bind->eval = eval_float_cast; break;
511 case TT_BOOL: bind->eval = eval_bool_cast; break;
512 case TT_STR: bind->eval = eval_string_cast; break;
513 case TT_SIN: bind->eval = eval_sin; break;
514 case TT_COS: bind->eval = eval_cos; break;
515 case TT_TAN: bind->eval = eval_tan; break;
516 case TT_ASIN: bind->eval = eval_asin; break;
517 case TT_ACOS: bind->eval = eval_acos; break;
518 case TT_ATAN: bind->eval = eval_atan; break;
519 case TT_LOGE: bind->eval = eval_loge; break;
520 case TT_LOGD: bind->eval = eval_logd; break;
521 case TT_LOG2: bind->eval = eval_log2; break;
522 case TT_EXP: bind->eval = eval_exp; break;
523 case TT_SQRT: bind->eval = eval_sqrt; break;
524 case TT_RAD: bind->eval = eval_rad; break;
525 case TT_DEG: bind->eval = eval_deg; break;
526 case TT_ABS: bind->eval = eval_abs; break;
527 default: bind->eval = NULL; break;
528 }
529 bind->type = ET_CALC;
530 bind->calc.left = right;
531 bind->calc.right = NULL;
532 bind->calc.cond = NULL;
533
534 *expr = bind;
535 return STATUS_OK;
536 }
537
538 status_t parse_sign(expr_t **expr, Tokenizer *t, size_t flags)
539 {
540 // Check token
541 token_t tok = t->get_token(flags);
542
543 // Parse right part
544 status_t res;
545 expr_t *right = NULL;
546
547 switch(tok)
548 {
549 case TT_ADD:
550 case TT_SUB:
551 if ((res = parse_sign(&right, t, TF_GET)) != STATUS_OK)
552 return res;
553 break;
554 default:
555 return parse_func(expr, t, TF_NONE);
556 }
557
558 // Create binding between left and right
559 expr_t *bind = parse_create_expr();
560 if (bind == NULL)
561 {
562 parse_destroy(right);
563 return STATUS_NO_MEM;
564 }
565 switch (tok)
566 {
567 case TT_ADD: bind->eval = eval_psign; break;
568 case TT_SUB: bind->eval = eval_nsign; break;
569 default: bind->eval = NULL; break;
570 }
571 bind->type = ET_CALC;
572 bind->calc.left = right;
573 bind->calc.right = NULL;
574 bind->calc.cond = NULL;
575
576 *expr = bind;
577 return STATUS_OK;
578 }
579
580 status_t parse_not(expr_t **expr, Tokenizer *t, size_t flags)
581 {
582 // Check token
583 token_t tok = t->get_token(flags);
584
585 // Parse right part
586 status_t res;
587 expr_t *right = NULL;
588 switch (tok)
589 {
590 case TT_NOT:
591 case TT_BNOT:
592 if ((res = parse_not(&right, t, TF_GET)) != STATUS_OK)
593 return res;
594 break;
595 default:
596 return parse_sign(expr, t, TF_NONE);
597 }
598
599 // Create binding between left and right
600 expr_t *bind = parse_create_expr();
601 if (bind == NULL)
602 {
603 parse_destroy(right);
604 return STATUS_NO_MEM;
605 }
606 bind->eval = (tok == TT_NOT) ? eval_not : eval_neg;
607 bind->type = ET_CALC;
608 bind->calc.left = right;
609 bind->calc.right = NULL;
610 bind->calc.cond = NULL;
611
612 *expr = bind;
613 return STATUS_OK;
614 }
615
616 status_t parse_power(expr_t **expr, Tokenizer *t, size_t flags)
617 {
618 expr_t *left = NULL, *right = NULL;
619
620 // Parse left part
621 status_t res = parse_not(&left, t, flags);
622 if (res != STATUS_OK)
623 return res;
624
625 while (true)
626 {
627 // Check token
628 token_t tok = t->get_token(TF_NONE);
629 if (tok != TT_POW)
630 {
631 *expr = left;
632 return STATUS_OK;
633 }
634
635 // Parse right part
636 res = parse_not(&right, t, TF_GET);
637 if (res != STATUS_OK)
638 {
639 parse_destroy(left);
640 return res;
641 }
642
643 // Create binding between left and right
644 expr_t *bind = parse_create_expr();
645 if (bind == NULL)
646 {
647 parse_destroy(left);
648 parse_destroy(right);
649 return STATUS_NO_MEM;
650 }
651 bind->eval = eval_power;
652 bind->type = ET_CALC;
653 bind->calc.left = left;
654 bind->calc.right = right;
655 bind->calc.cond = NULL;
656
657 left = bind;
658 }
659 }
660
661 status_t parse_muldiv(expr_t **expr, Tokenizer *t, size_t flags)
662 {
663 expr_t *left = NULL, *right = NULL;
664
665 // Parse left part
666 status_t res = parse_power(&left, t, flags);
667 if (res != STATUS_OK)
668 return res;
669
670 while (true)
671 {
672 // Check token
673 token_t tok = t->get_token(TF_NONE);
674 switch (tok)
675 {
676 case TT_MUL:
677 case TT_DIV:
678 case TT_IMUL:
679 case TT_IDIV:
680 case TT_FMOD:
681 case TT_IMOD:
682 break;
683 default:
684 *expr = left;
685 return res;
686 }
687
688 // Parse right part
689 res = parse_power(&right, t, TF_GET);
690 if (res != STATUS_OK)
691 {
692 parse_destroy(left);
693 return res;
694 }
695
696 // Create binding between left and right
697 expr_t *bind = parse_create_expr();
698 if (bind == NULL)
699 {
700 parse_destroy(left);
701 parse_destroy(right);
702 return STATUS_NO_MEM;
703 }
704 switch (tok)
705 {
706 case TT_MUL: bind->eval = eval_mul; break;
707 case TT_DIV: bind->eval = eval_div; break;
708 case TT_IMUL: bind->eval = eval_imul; break;
709 case TT_IDIV: bind->eval = eval_idiv; break;
710 case TT_FMOD: bind->eval = eval_fmod; break;
711 case TT_IMOD: bind->eval = eval_imod; break;
712 default: bind->eval = NULL; break;
713 }
714 bind->type = ET_CALC;
715 bind->calc.left = left;
716 bind->calc.right = right;
717 bind->calc.cond = NULL;
718
719 // Update left expression
720 left = bind;
721 }
722 }
723
724 status_t parse_addsub(expr_t **expr, Tokenizer *t, size_t flags)
725 {
726 expr_t *left = NULL, *right = NULL;
727
728 // Parse left part
729 status_t res = parse_muldiv(&left, t, flags);
730 if (res != STATUS_OK)
731 return res;
732
733 // Parse right part
734 while (true)
735 {
736 // Check token
737 token_t tok = t->get_token(TF_NONE);
738 switch (tok)
739 {
740 case TT_ADD:
741 case TT_SUB:
742 case TT_ADDSYM:
743 case TT_SUBSYM:
744 case TT_IADD:
745 case TT_ISUB:
746 break;
747 default:
748 *expr = left;
749 return res;
750 }
751
752 // Parse right expression
753 res = parse_muldiv(&right, t, TF_GET);
754 if (res != STATUS_OK)
755 {
756 parse_destroy(left);
757 return res;
758 }
759
760 // Create binding between left and right
761 expr_t *bind = parse_create_expr();
762 if (bind == NULL)
763 {
764 parse_destroy(left);
765 parse_destroy(right);
766 return STATUS_NO_MEM;
767 }
768 switch (tok)
769 {
770 case TT_ADD: bind->eval = eval_add; break;
771 case TT_SUB: bind->eval = eval_sub; break;
772 case TT_ADDSYM: bind->eval = eval_add; break;
773 case TT_SUBSYM: bind->eval = eval_sub; break;
774 case TT_IADD: bind->eval = eval_iadd; break;
775 case TT_ISUB: bind->eval = eval_isub; break;
776 default: bind->eval = NULL; break;
777 }
778 bind->type = ET_CALC;
779 bind->calc.left = left;
780 bind->calc.right = right;
781 bind->calc.cond = NULL;
782
783 // Update left expression
784 left = bind;
785 }
786 }
787
788 status_t parse_strrep(expr_t **expr, Tokenizer *t, size_t flags)
789 {
790 expr_t *left = NULL, *right = NULL;
791
792 // Parse left part
793 status_t res = parse_addsub(&left, t, flags);
794 if (res != STATUS_OK)
795 return res;
796
797 // Check token
798 token_t tok = t->get_token(TF_NONE);
799 if (tok != TT_SREP)
800 {
801 *expr = left;
802 return res;
803 }
804
805 // Parse right part
806 res = parse_addsub(&right, t, TF_GET);
807 if (res != STATUS_OK)
808 {
809 parse_destroy(left);
810 return res;
811 }
812
813 // Create binding between left and right
814 expr_t *bind = parse_create_expr();
815 if (bind == NULL)
816 {
817 parse_destroy(left);
818 parse_destroy(right);
819 return STATUS_NO_MEM;
820 }
821
822 bind->type = ET_CALC;
823 bind->eval = eval_strrep;
824 bind->calc.left = left;
825 bind->calc.right = right;
826 bind->calc.cond = NULL;
827
828 *expr = bind;
829 return STATUS_OK;
830 }
831
832 status_t parse_strcat(expr_t **expr, Tokenizer *t, size_t flags)
833 {
834 expr_t *left = NULL, *right = NULL;
835
836 // Parse left part
837 status_t res = parse_strrep(&left, t, flags);
838 if (res != STATUS_OK)
839 return res;
840
841 // Check token
842 token_t tok = t->get_token(TF_NONE);
843 if (tok != TT_SCAT)
844 {
845 *expr = left;
846 return res;
847 }
848
849 // Parse right part
850 res = parse_strcat(&right, t, TF_GET);
851 if (res != STATUS_OK)
852 {
853 parse_destroy(left);
854 return res;
855 }
856
857 // Create binding between left and right
858 expr_t *bind = parse_create_expr();
859 if (bind == NULL)
860 {
861 parse_destroy(left);
862 parse_destroy(right);
863 return STATUS_NO_MEM;
864 }
865
866 bind->type = ET_CALC;
867 bind->eval = eval_strcat;
868 bind->calc.left = left;
869 bind->calc.right = right;
870 bind->calc.cond = NULL;
871
872 *expr = bind;
873 return STATUS_OK;
874 }
875
876 status_t parse_cmp_rel(expr_t **expr, Tokenizer *t, size_t flags)
877 {
878 expr_t *left = NULL, *right = NULL;
879
880 // Parse left part
881 status_t res = parse_strcat(&left, t, flags);
882 if (res != STATUS_OK)
883 return res;
884
885 // Check token
886 token_t tok = t->get_token(TF_NONE);
887 switch (tok)
888 {
889 case TT_LESS:
890 case TT_GREATER:
891 case TT_LESS_EQ:
892 case TT_GREATER_EQ:
893 case TT_ILESS:
894 case TT_IGREATER:
895 case TT_ILESS_EQ:
896 case TT_IGREATER_EQ:
897 break;
898 default:
899 *expr = left;
900 return res;
901 }
902
903 // Parse right part
904 res = parse_cmp_rel(&right, t, TF_GET);
905 if (res != STATUS_OK)
906 {
907 parse_destroy(left);
908 return res;
909 }
910
911 // Create binding between left and right
912 expr_t *bind = parse_create_expr();
913 if (bind == NULL)
914 {
915 parse_destroy(left);
916 parse_destroy(right);
917 return STATUS_NO_MEM;
918 }
919 switch (tok)
920 {
921 case TT_LESS: bind->eval = eval_cmp_lt; break;
922 case TT_GREATER: bind->eval = eval_cmp_gt; break;
923 case TT_LESS_EQ: bind->eval = eval_cmp_le; break;
924 case TT_GREATER_EQ: bind->eval = eval_cmp_ge; break;
925 case TT_ILESS: bind->eval = eval_icmp_lt; break;
926 case TT_IGREATER: bind->eval = eval_icmp_gt; break;
927 case TT_ILESS_EQ: bind->eval = eval_icmp_le; break;
928 case TT_IGREATER_EQ: bind->eval = eval_icmp_ge; break;
929 default: bind->eval = NULL; break;
930 }
931 bind->type = ET_CALC;
932 bind->calc.left = left;
933 bind->calc.right = right;
934 bind->calc.cond = NULL;
935
936 *expr = bind;
937 return STATUS_OK;
938 }
939
940 status_t parse_cmp_eq(expr_t **expr, Tokenizer *t, size_t flags)
941 {
942 expr_t *left = NULL, *right = NULL;
943
944 // Parse left part
945 status_t res = parse_cmp_rel(&left, t, flags);
946 if (res != STATUS_OK)
947 return res;
948
949 // Check token
950 token_t tok = t->get_token(TF_NONE);
951 switch (tok)
952 {
953 case TT_NOT_EQ:
954 case TT_EQ:
955 case TT_CMP:
956 case TT_INOT_EQ:
957 case TT_IEQ:
958 case TT_ICMP:
959 break;
960 default:
961 *expr = left;
962 return res;
963 }
964
965 // Parse right part
966 res = parse_cmp_eq(&right, t, TF_GET);
967 if (res != STATUS_OK)
968 {
969 parse_destroy(left);
970 return res;
971 }
972
973 // Create binding between left and right
974 expr_t *bind = parse_create_expr();
975 if (bind == NULL)
976 {
977 parse_destroy(left);
978 parse_destroy(right);
979 return STATUS_NO_MEM;
980 }
981 switch (tok)
982 {
983 case TT_NOT_EQ: bind->eval = eval_cmp_ne; break;
984 case TT_EQ: bind->eval = eval_cmp_eq; break;
985 case TT_CMP: bind->eval = eval_cmp; break;
986 case TT_INOT_EQ: bind->eval = eval_icmp_ne; break;
987 case TT_IEQ: bind->eval = eval_icmp_eq; break;
988 case TT_ICMP: bind->eval = eval_icmp; break;
989 default: bind->eval = NULL; break;
990 }
991 bind->type = ET_CALC;
992 bind->calc.left = left;
993 bind->calc.right = right;
994 bind->calc.cond = NULL;
995
996 *expr = bind;
997 return STATUS_OK;
998 }
999
1000 status_t parse_bit_and(expr_t **expr, Tokenizer *t, size_t flags)
1001 {
1002 expr_t *left = NULL, *right = NULL;
1003
1004 // Parse left part
1005 status_t res = parse_cmp_eq(&left, t, flags);
1006 if (res != STATUS_OK)
1007 return res;
1008
1009 // Check token
1010 while (true)
1011 {
1012 token_t tok = t->get_token(TF_NONE);
1013 if (tok != TT_BAND)
1014 {
1015 *expr = left;
1016 return STATUS_OK;
1017 }
1018
1019 // Parse right part
1020 res = parse_cmp_eq(&right, t, TF_GET);
1021 if (res != STATUS_OK)
1022 {
1023 parse_destroy(left);
1024 return res;
1025 }
1026
1027 // Create binding between left and right
1028 expr_t *bind = parse_create_expr();
1029 if (bind == NULL)
1030 {
1031 parse_destroy(left);
1032 parse_destroy(right);
1033 return STATUS_NO_MEM;
1034 }
1035 bind->eval = eval_bit_and;
1036 bind->type = ET_CALC;
1037 bind->calc.left = left;
1038 bind->calc.right = right;
1039 bind->calc.cond = NULL;
1040
1041 // Store left
1042 left = bind;
1043 }
1044 return STATUS_OK;
1045 }
1046
1047 status_t parse_bit_xor(expr_t **expr, Tokenizer *t, size_t flags)
1048 {
1049 expr_t *left = NULL, *right = NULL;
1050
1051 // Parse left part
1052 status_t res = parse_bit_and(&left, t, flags);
1053 if (res != STATUS_OK)
1054 return res;
1055
1056 // Check token
1057 token_t tok = t->get_token(TF_NONE);
1058 if (tok != TT_BXOR)
1059 {
1060 *expr = left;
1061 return STATUS_OK;
1062 }
1063
1064 // Parse right part
1065 res = parse_bit_xor(&right, t, TF_GET);
1066 if (res != STATUS_OK)
1067 {
1068 parse_destroy(left);
1069 return res;
1070 }
1071
1072 // Create binding between left and right
1073 expr_t *bind = parse_create_expr();
1074 if (bind == NULL)
1075 {
1076 parse_destroy(left);
1077 parse_destroy(right);
1078 return STATUS_NO_MEM;
1079 }
1080 bind->eval = eval_bit_xor;
1081 bind->type = ET_CALC;
1082 bind->calc.left = left;
1083 bind->calc.right = right;
1084 bind->calc.cond = NULL;
1085
1086 *expr = bind;
1087 return STATUS_OK;
1088 }
1089
1090 status_t parse_bit_or(expr_t **expr, Tokenizer *t, size_t flags)
1091 {
1092 expr_t *left = NULL, *right = NULL;
1093
1094 // Parse left part
1095 status_t res = parse_bit_xor(&left, t, flags);
1096 if (res != STATUS_OK)
1097 return res;
1098
1099 // Check token
1100 token_t tok = t->get_token(TF_NONE);
1101 if (tok != TT_BOR)
1102 {
1103 *expr = left;
1104 return STATUS_OK;
1105 }
1106
1107 // Parse right part
1108 res = parse_bit_or(&right, t, TF_GET);
1109 if (res != STATUS_OK)
1110 {
1111 parse_destroy(left);
1112 return res;
1113 }
1114
1115 // Create binding between left and right
1116 expr_t *bind = parse_create_expr();
1117 if (bind == NULL)
1118 {
1119 parse_destroy(left);
1120 parse_destroy(right);
1121 return STATUS_NO_MEM;
1122 }
1123 bind->eval = eval_bit_or;
1124 bind->type = ET_CALC;
1125 bind->calc.left = left;
1126 bind->calc.right = right;
1127 bind->calc.cond = NULL;
1128
1129 *expr = bind;
1130 return STATUS_OK;
1131 }
1132
1133 status_t parse_and(expr_t **expr, Tokenizer *t, size_t flags)
1134 {
1135 expr_t *left = NULL, *right = NULL;
1136
1137 // Parse left part
1138 status_t res = parse_bit_or(&left, t, flags);
1139 if (res != STATUS_OK)
1140 return res;
1141
1142 // Check token
1143 token_t tok = t->get_token(TF_NONE);
1144 if (tok != TT_AND)
1145 {
1146 *expr = left;
1147 return STATUS_OK;
1148 }
1149
1150 // Parse right part
1151 res = parse_and(&right, t, TF_GET);
1152 if (res != STATUS_OK)
1153 {
1154 parse_destroy(left);
1155 return res;
1156 }
1157
1158 // Create binding between left and right
1159 expr_t *bind = parse_create_expr();
1160 if (bind == NULL)
1161 {
1162 parse_destroy(left);
1163 parse_destroy(right);
1164 return STATUS_NO_MEM;
1165 }
1166 bind->eval = eval_and;
1167 bind->type = ET_CALC;
1168 bind->calc.left = left;
1169 bind->calc.right = right;
1170 bind->calc.cond = NULL;
1171
1172 *expr = bind;
1173 return STATUS_OK;
1174 }
1175
1176 status_t parse_xor(expr_t **expr, Tokenizer *t, size_t flags)
1177 {
1178 expr_t *left = NULL, *right = NULL;
1179
1180 // Parse left part
1181 status_t res = parse_and(&left, t, flags);
1182 if (res != STATUS_OK)
1183 return res;
1184
1185 // Check token
1186 token_t tok = t->get_token(TF_NONE);
1187 if (tok != TT_XOR)
1188 {
1189 *expr = left;
1190 return res;
1191 }
1192
1193 // Parse right part
1194 res = parse_xor(&right, t, TF_GET);
1195 if (res != STATUS_OK)
1196 {
1197 parse_destroy(left);
1198 return res;
1199 }
1200
1201 // Create binding between left and right
1202 expr_t *bind = parse_create_expr();
1203 if (bind == NULL)
1204 {
1205 parse_destroy(left);
1206 parse_destroy(right);
1207 return STATUS_NO_MEM;
1208 }
1209 bind->eval = eval_xor;
1210 bind->type = ET_CALC;
1211 bind->calc.left = left;
1212 bind->calc.right = right;
1213 bind->calc.cond = NULL;
1214
1215 *expr = bind;
1216 return STATUS_OK;
1217 }
1218
1219 status_t parse_or(expr_t **expr, Tokenizer *t, size_t flags)
1220 {
1221 expr_t *left = NULL, *right = NULL;
1222
1223 // Parse left part
1224 status_t res = parse_xor(&left, t, flags);
1225 if (res != STATUS_OK)
1226 return res;
1227
1228 // Check token
1229 token_t tok = t->get_token(TF_NONE);
1230 if (tok != TT_OR)
1231 {
1232 *expr = left;
1233 return STATUS_OK;
1234 }
1235
1236 // Parse right part
1237 res = parse_or(&right, t, TF_GET);
1238 if (res != STATUS_OK)
1239 {
1240 parse_destroy(left);
1241 return res;
1242 }
1243
1244 // Create binding between left and right
1245 expr_t *bind = parse_create_expr();
1246 if (bind == NULL)
1247 {
1248 parse_destroy(left);
1249 parse_destroy(right);
1250 return STATUS_NO_MEM;
1251 }
1252 bind->eval = eval_or;
1253 bind->type = ET_CALC;
1254 bind->calc.left = left;
1255 bind->calc.right = right;
1256 bind->calc.cond = NULL;
1257
1258 *expr = bind;
1259 return STATUS_OK;
1260 }
1261
1262 status_t parse_ternary(expr_t **expr, Tokenizer *t, size_t flags)
1263 {
1264 expr_t *cond = NULL, *left = NULL, *right = NULL;
1265
1266 // Parse condition part
1267 status_t res = parse_or(&cond, t, flags);
1268 if (res != STATUS_OK)
1269 return res;
1270
1271 // Check token
1272 token_t tok = t->get_token(TF_NONE);
1273 if (tok != TT_QUESTION)
1274 {
1275 *expr = cond;
1276 return res;
1277 }
1278
1279 // Parse left part
1280 res = parse_ternary(&left, t, TF_GET);
1281 if (res != STATUS_OK)
1282 {
1283 parse_destroy(cond);
1284 return res;
1285 }
1286
1287 // Check token
1288 tok = t->get_token(TF_NONE);
1289 if (tok != TT_COLON)
1290 {
1291 parse_destroy(cond);
1292 return res;
1293 }
1294
1295 // Parse right part
1296 res = parse_ternary(&right, t, TF_GET);
1297 if (res != STATUS_OK)
1298 {
1299 parse_destroy(cond);
1300 parse_destroy(left);
1301 return res;
1302 }
1303
1304 // Create binding between left and right
1305 expr_t *bind = parse_create_expr();
1306 if (bind == NULL)
1307 {
1308 parse_destroy(cond);
1309 parse_destroy(left);
1310 parse_destroy(right);
1311 return STATUS_NO_MEM;
1312 }
1313 bind->eval = eval_ternary;
1314 bind->type = ET_CALC;
1315 bind->calc.left = left;
1316 bind->calc.right = right;
1317 bind->calc.cond = cond;
1318
1319 *expr = bind;
1320 return STATUS_OK;
1321 }
1322
1323 status_t parse_expression(expr_t **expr, Tokenizer *t, size_t flags)
1324 {
1325 return parse_ternary(expr, t, flags);
1326 }
1327
1328 } /* namespace expr */
1329 } /* namespace lsp */
1330
1331