/[svn]/linuxsampler/trunk/src/scriptvm/tree.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/scriptvm/tree.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3034 - (show annotations) (download)
Mon Oct 31 00:05:00 2016 UTC (7 years, 4 months ago) by schoenebeck
File size: 28034 byte(s)
* Fixed a bunch of minor issues (mostly compiler warnings).
* Bumped version (2.0.0.svn31).

1 /*
2 * Copyright (c) 2014 - 2016 Christian Schoenebeck and Andreas Persson
3 *
4 * http://www.linuxsampler.org
5 *
6 * This file is part of LinuxSampler and released under the same terms.
7 * See README file for details.
8 */
9
10 #include <cstdio>
11 #include <string.h>
12 #include "tree.h"
13 #include "../common/global_private.h"
14 #include <assert.h>
15
16 namespace LinuxSampler {
17
18 bool isNoOperation(StatementRef statement) {
19 NoOperation* noOp = dynamic_cast<NoOperation*>(&*statement);
20 return noOp;
21 }
22
23 Node::Node() {
24 }
25
26 Node::~Node() {
27 }
28
29 void Node::printIndents(int n) {
30 for (int i = 0; i < n; ++i) printf(" ");
31 fflush(stdout);
32 }
33
34 String IntExpr::evalCastToStr() {
35 return ToString(evalInt());
36 }
37
38 int IntLiteral::evalInt() {
39 return value;
40 }
41
42 void IntLiteral::dump(int level) {
43 printIndents(level);
44 printf("IntLiteral %d\n", value);
45 }
46
47 void StringLiteral::dump(int level) {
48 printIndents(level);
49 printf("StringLiteral: '%s'\n", value.c_str());
50 }
51
52 int Add::evalInt() {
53 IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
54 IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
55 return (pLHS && pRHS) ? pLHS->evalInt() + pRHS->evalInt() : 0;
56 }
57
58 void Add::dump(int level) {
59 printIndents(level);
60 printf("Add(\n");
61 lhs->dump(level+1);
62 printIndents(level);
63 printf(",\n");
64 rhs->dump(level+1);
65 printIndents(level);
66 printf(")\n");
67 }
68
69 int Sub::evalInt() {
70 IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
71 IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
72 return (pLHS && pRHS) ? pLHS->evalInt() - pRHS->evalInt() : 0;
73 }
74
75 void Sub::dump(int level) {
76 printIndents(level);
77 printf("Sub(\n");
78 lhs->dump(level+1);
79 printIndents(level);
80 printf(",\n");
81 rhs->dump(level+1);
82 printIndents(level);
83 printf(")\n");
84 }
85
86 int Mul::evalInt() {
87 IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
88 IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
89 return (pLHS && pRHS) ? pLHS->evalInt() * pRHS->evalInt() : 0;
90 }
91
92 void Mul::dump(int level) {
93 printIndents(level);
94 printf("Mul(\n");
95 lhs->dump(level+1);
96 printIndents(level);
97 printf(",\n");
98 rhs->dump(level+1);
99 printIndents(level);
100 printf(")\n");
101 }
102
103 int Div::evalInt() {
104 IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
105 IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
106 if (!pLHS || !pRHS) return 0;
107 int l = pLHS->evalInt();
108 int r = pRHS->evalInt();
109 if (r == 0) return 0;
110 return l / r;
111 }
112
113 void Div::dump(int level) {
114 printIndents(level);
115 printf("Div(\n");
116 lhs->dump(level+1);
117 printIndents(level);
118 printf(",\n");
119 rhs->dump(level+1);
120 printIndents(level);
121 printf(")\n");
122 }
123
124 int Mod::evalInt() {
125 IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
126 IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
127 return (pLHS && pRHS) ? pLHS->evalInt() % pRHS->evalInt() : 0;
128 }
129
130 void Mod::dump(int level) {
131 printIndents(level);
132 printf("Mod(\n");
133 lhs->dump(level+1);
134 printIndents(level);
135 printf(",\n");
136 rhs->dump(level+1);
137 printIndents(level);
138 printf(")\n");
139 }
140
141 void Args::dump(int level) {
142 printIndents(level);
143 printf("Args(\n");
144 for (std::vector<ExpressionRef>::iterator it = args.begin() ; it != args.end() ; ++it) {
145 (*it)->dump(level+1);
146 }
147 printIndents(level);
148 printf(")\n");
149 }
150
151 bool Args::isPolyphonic() const {
152 for (int i = 0; i < args.size(); ++i)
153 if (args[i]->isPolyphonic())
154 return true;
155 return false;
156 }
157
158 EventHandlers::EventHandlers() {
159 //printf("EventHandlers::Constructor 0x%lx\n", (long long)this);
160 }
161
162 EventHandlers::~EventHandlers() {
163 }
164
165 void EventHandlers::add(EventHandlerRef arg) {
166 args.push_back(arg);
167 }
168
169 void EventHandlers::dump(int level) {
170 printIndents(level);
171 printf("EventHandlers {\n");
172 for (std::vector<EventHandlerRef>::iterator it = args.begin() ; it != args.end() ; ++it) {
173 (*it)->dump(level+1);
174 }
175 printIndents(level);
176 printf("}\n");
177 }
178
179 EventHandler* EventHandlers::eventHandlerByName(const String& name) const {
180 for (int i = 0; i < args.size(); ++i)
181 if (args.at(i)->eventHandlerName() == name)
182 return const_cast<EventHandler*>(&*args.at(i));
183 return NULL;
184 }
185
186 EventHandler* EventHandlers::eventHandler(uint index) const {
187 if (index >= args.size()) return NULL;
188 return const_cast<EventHandler*>(&*args.at(index));
189 }
190
191 bool EventHandlers::isPolyphonic() const {
192 for (int i = 0; i < args.size(); ++i)
193 if (args[i]->isPolyphonic())
194 return true;
195 return false;
196 }
197
198 Assignment::Assignment(VariableRef variable, ExpressionRef value)
199 : variable(variable), value(value)
200 {
201 }
202
203 void Assignment::dump(int level) {
204 printIndents(level);
205 printf("Assignment\n");
206 }
207
208 StmtFlags_t Assignment::exec() {
209 if (!variable)
210 return StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
211 variable->assign(&*value);
212 return STMT_SUCCESS;
213 }
214
215 EventHandler::EventHandler(StatementsRef statements) {
216 this->statements = statements;
217 usingPolyphonics = statements->isPolyphonic();
218 }
219
220 void EventHandler::dump(int level) {
221 printIndents(level);
222 printf("EventHandler {\n");
223 statements->dump(level+1);
224 printIndents(level);
225 printf("}\n");
226 }
227
228 void Statements::dump(int level) {
229 printIndents(level);
230 printf("Statements {\n");
231 for (std::vector<StatementRef>::iterator it = args.begin() ; it != args.end() ; ++it) {
232 (*it)->dump(level+1);
233 }
234 printIndents(level);
235 printf("}\n");
236 }
237
238 Statement* Statements::statement(uint i) {
239 if (i >= args.size()) return NULL;
240 return &*args.at(i);
241 }
242
243 bool Statements::isPolyphonic() const {
244 for (int i = 0; i < args.size(); ++i)
245 if (args[i]->isPolyphonic())
246 return true;
247 return false;
248 }
249
250 DynamicVariableCall::DynamicVariableCall(const String& name, ParserContext* ctx, VMDynVar* v)
251 : Variable(ctx, 0, false), dynVar(v), varName(name)
252 {
253 }
254
255 int DynamicVariableCall::evalInt() {
256 VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);
257 if (!expr) return 0;
258 return expr->evalInt();
259 }
260
261 String DynamicVariableCall::evalStr() {
262 VMStringExpr* expr = dynamic_cast<VMStringExpr*>(dynVar);
263 if (!expr) return "";
264 return expr->evalStr();
265 }
266
267 String DynamicVariableCall::evalCastToStr() {
268 if (dynVar->exprType() == STRING_EXPR) {
269 return evalStr();
270 } else {
271 VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(dynVar);
272 return intExpr ? ToString(intExpr->evalInt()) : "";
273 }
274 }
275
276 void DynamicVariableCall::dump(int level) {
277 printIndents(level);
278 printf("Dynamic Variable '%s'\n", varName.c_str());
279 }
280
281 void FunctionCall::dump(int level) {
282 printIndents(level);
283 printf("FunctionCall '%s' args={\n", functionName.c_str());
284 args->dump(level+1);
285 printIndents(level);
286 printf("}\n");
287 }
288
289 ExprType_t FunctionCall::exprType() const {
290 if (!fn) return EMPTY_EXPR;
291 return fn->returnType();
292 }
293
294 VMFnResult* FunctionCall::execVMFn() {
295 if (!fn) return NULL;
296 // assuming here that all argument checks (amount and types) have been made
297 // at parse time, to avoid time intensive checks on each function call
298 return fn->exec(dynamic_cast<VMFnArgs*>(&*args));
299 }
300
301 StmtFlags_t FunctionCall::exec() {
302 VMFnResult* result = execVMFn();
303 if (!result)
304 return StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
305 return result->resultFlags();
306 }
307
308 int FunctionCall::evalInt() {
309 VMFnResult* result = execVMFn();
310 if (!result) return 0;
311 VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
312 if (!intExpr) return 0;
313 return intExpr->evalInt();
314 }
315
316 String FunctionCall::evalStr() {
317 VMFnResult* result = execVMFn();
318 if (!result) return "";
319 VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());
320 if (!strExpr) return "";
321 return strExpr->evalStr();
322 }
323
324 String FunctionCall::evalCastToStr() {
325 VMFnResult* result = execVMFn();
326 if (!result) return "";
327 if (result->resultValue()->exprType() == STRING_EXPR) {
328 VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());
329 return strExpr ? strExpr->evalStr() : "";
330 } else {
331 VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
332 return intExpr ? ToString(intExpr->evalInt()) : "";
333 }
334 }
335
336 IntVariable::IntVariable(ParserContext* ctx)
337 : Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false), polyphonic(false)
338 {
339 //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);
340 assert(ctx);
341 }
342
343 inline static int postfixInc(int& object, int incBy) {
344 const int i = object;
345 object += incBy;
346 return i;
347 }
348
349 IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)
350 : Variable(ctx, !ctx ? 0 : polyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) : postfixInc(ctx->globalIntVarCount, size), bConst),
351 polyphonic(polyphonic)
352 {
353 //printf("InvVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);
354 if (polyphonic) {
355 //printf("polyIntVar memPOS=%d\n", memPos);
356 assert(ctx);
357 }
358 }
359
360 void IntVariable::assign(Expression* expr) {
361 IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
362 if (intExpr) {
363 if (polyphonic)
364 context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();
365 else
366 (*context->globalIntMemory)[memPos] = intExpr->evalInt();
367 }
368 }
369
370 int IntVariable::evalInt() {
371 //printf("IntVariable::eval pos=%d\n", memPos);
372 if (polyphonic) {
373 //printf("evalInt() poly memPos=%d execCtx=0x%lx\n", memPos, (uint64_t)context->execContext);
374 return context->execContext->polyphonicIntMemory[memPos];
375 }
376 return (*context->globalIntMemory)[memPos];
377 }
378
379 void IntVariable::dump(int level) {
380 printIndents(level);
381 printf("IntVariable\n");
382 //printf("IntVariable memPos=%d\n", memPos);
383 }
384
385 //ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)
386 ConstIntVariable::ConstIntVariable(int value)
387 : IntVariable(NULL,false,true), value(value)
388 {
389 }
390
391 void ConstIntVariable::assign(Expression* expr) {
392 // ignore assignment
393 /*
394 printf("ConstIntVariable::assign()\n");
395 IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
396 if (intExpr) {
397 value = intExpr->evalInt();
398 }
399 */
400 }
401
402 int ConstIntVariable::evalInt() {
403 return value;
404 }
405
406 void ConstIntVariable::dump(int level) {
407 printIndents(level);
408 printf("ConstIntVariable val=%d\n", value);
409 }
410
411 BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntRelPtr* ptr)
412 : IntVariable(NULL,false,false), name(name), ptr(ptr)
413 {
414 }
415
416 void BuiltInIntVariable::assign(Expression* expr) {
417 IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
418 if (!valueExpr) return;
419 ptr->assign(valueExpr->evalInt());
420 }
421
422 int BuiltInIntVariable::evalInt() {
423 return ptr->evalInt();
424 }
425
426 void BuiltInIntVariable::dump(int level) {
427 printIndents(level);
428 printf("Built-in IntVar '%s'\n", name.c_str());
429 }
430
431 PolyphonicIntVariable::PolyphonicIntVariable(ParserContext* ctx)
432 : IntVariable(ctx,true,false)
433 {
434 }
435
436 void PolyphonicIntVariable::dump(int level) {
437 printIndents(level);
438 printf("PolyphonicIntVariable\n");
439 }
440
441 IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size)
442 : Variable(ctx, 0, false)
443 {
444 values.resize(size);
445 memset(&values[0], 0, size * sizeof(int));
446 }
447
448 IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size, ArgsRef values)
449 : Variable(ctx, 0, false)
450 {
451 this->values.resize(size);
452 for (int i = 0; i < values->argsCount(); ++i) {
453 VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));
454 if (expr) this->values[i] = expr->evalInt();
455 }
456 }
457
458 IntArrayVariable::IntArrayVariable(ParserContext* ctx, bool bConst)
459 : Variable(ctx, 0, bConst)
460 {
461 }
462
463 int IntArrayVariable::evalIntElement(uint i) {
464 if (i >= values.size()) return 0;
465 return values[i];
466 }
467
468 void IntArrayVariable::assignIntElement(uint i, int value) {
469 if (i >= values.size()) return;
470 values[i] = value;
471 }
472
473 void IntArrayVariable::dump(int level) {
474 printIndents(level);
475 printf("IntArray(");
476 for (int i = 0; i < values.size(); ++i) {
477 if (i % 12 == 0) {
478 printf("\n");
479 printIndents(level+1);
480 }
481 printf("%d, ", values[i]);
482 }
483 printIndents(level);
484 printf(")\n");
485 }
486
487 BuiltInIntArrayVariable::BuiltInIntArrayVariable(const String& name, VMInt8Array* array)
488 : IntArrayVariable(NULL, false), name(name), array(array)
489 {
490 }
491
492 int BuiltInIntArrayVariable::evalIntElement(uint i) {
493 return i >= array->size ? 0 : array->data[i];
494 }
495
496 void BuiltInIntArrayVariable::assignIntElement(uint i, int value) {
497 if (i >= array->size) return;
498 array->data[i] = value;
499 }
500
501 void BuiltInIntArrayVariable::dump(int level) {
502 printIndents(level);
503 printf("Built-In Int Array Variable '%s'\n", name.c_str());
504 }
505
506 IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)
507 : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)
508 {
509 }
510
511 void IntArrayElement::assign(Expression* expr) {
512 IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
513 if (!valueExpr) return;
514 int value = valueExpr->evalInt();
515
516 if (!index) return;
517 int idx = index->evalInt();
518 if (idx < 0 || idx >= array->arraySize()) return;
519
520 array->assignIntElement(idx, value);
521 }
522
523 int IntArrayElement::evalInt() {
524 if (!index) return 0;
525 int idx = index->evalInt();
526 if (idx < 0 || idx >= array->arraySize()) return 0;
527
528 return array->evalIntElement(idx);
529 }
530
531 void IntArrayElement::dump(int level) {
532 printIndents(level);
533 printf("IntArrayElement\n");
534 }
535
536 StringVariable::StringVariable(ParserContext* ctx)
537 : Variable(ctx,ctx->globalStrVarCount++,false)
538 {
539 }
540
541 StringVariable::StringVariable(ParserContext* ctx, bool bConst)
542 : Variable(ctx,0,bConst)
543 {
544 }
545
546 void StringVariable::assign(Expression* expr) {
547 StringExpr* strExpr = dynamic_cast<StringExpr*>(expr);
548 (*context->globalStrMemory)[memPos] = strExpr->evalStr();
549 }
550
551 String StringVariable::evalStr() {
552 //printf("StringVariable::eval pos=%d\n", memPos);
553 return (*context->globalStrMemory)[memPos];
554 }
555
556 void StringVariable::dump(int level) {
557 printIndents(level);
558 printf("StringVariable memPos=%d\n", memPos);
559 }
560
561 ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)
562 : StringVariable(ctx,true), value(_value)
563 {
564 }
565
566 void ConstStringVariable::assign(Expression* expr) {
567 // ignore assignment
568 // StringExpr* strExpr = dynamic_cast<StringExpr*>(expr);
569 // if (strExpr) value = strExpr->evalStr();
570 }
571
572 String ConstStringVariable::evalStr() {
573 return value;
574 }
575
576 void ConstStringVariable::dump(int level) {
577 printIndents(level);
578 printf("ConstStringVariable val='%s'\n", value.c_str());
579 }
580
581 void If::dump(int level) {
582 printIndents(level);
583 if (ifStatements && elseStatements)
584 printf("if cond stmts1 else stmts2 end if\n");
585 else if (ifStatements)
586 printf("if cond statements end if\n");
587 else
588 printf("if [INVALID]\n");
589 }
590
591 int If::evalBranch() {
592 if (condition->evalInt()) return 0;
593 if (elseStatements) return 1;
594 return -1;
595 }
596
597 Statements* If::branch(uint i) const {
598 if (i == 0) return (Statements*) &*ifStatements;
599 if (i == 1) return (elseStatements) ? (Statements*) &*elseStatements : NULL;
600 return NULL;
601 }
602
603 bool If::isPolyphonic() const {
604 if (condition->isPolyphonic() || ifStatements->isPolyphonic())
605 return true;
606 return elseStatements ? elseStatements->isPolyphonic() : false;
607 }
608
609 void SelectCase::dump(int level) {
610 printIndents(level);
611 if (select)
612 if (select->isConstExpr())
613 printf("Case select %d\n", select->evalInt());
614 else
615 printf("Case select [runtime expr]\n");
616 else
617 printf("Case select NULL\n");
618 for (int i = 0; i < branches.size(); ++i) {
619 printIndents(level+1);
620 CaseBranch& branch = branches[i];
621 if (branch.from && branch.to)
622 if (branch.from->isConstExpr() && branch.to->isConstExpr())
623 printf("case %d to %d\n", branch.from->evalInt(), branch.to->evalInt());
624 else if (branch.from->isConstExpr() && !branch.to->isConstExpr())
625 printf("case %d to [runtime expr]\n", branch.from->evalInt());
626 else if (!branch.from->isConstExpr() && branch.to->isConstExpr())
627 printf("case [runtime expr] to %d\n", branch.to->evalInt());
628 else
629 printf("case [runtime expr] to [runtime expr]\n");
630 else if (branch.from)
631 if (branch.from->isConstExpr())
632 printf("case %d\n", branch.from->evalInt());
633 else
634 printf("case [runtime expr]\n");
635 else
636 printf("case NULL\n");
637 }
638 }
639
640 int SelectCase::evalBranch() {
641 int value = select->evalInt();
642 for (int i = 0; i < branches.size(); ++i) {
643 if (branches.at(i).from && branches.at(i).to) { // i.e. "case 4 to 7" ...
644 if (branches.at(i).from->evalInt() <= value &&
645 branches.at(i).to->evalInt() >= value) return i;
646 } else { // i.e. "case 5" ...
647 if (branches.at(i).from->evalInt() == value) return i;
648 }
649 }
650 return -1;
651 }
652
653 Statements* SelectCase::branch(uint i) const {
654 if (i < branches.size())
655 return const_cast<Statements*>( &*branches[i].statements );
656 return NULL;
657 }
658
659 bool SelectCase::isPolyphonic() const {
660 if (select->isPolyphonic()) return true;
661 for (int i = 0; i < branches.size(); ++i)
662 if (branches[i].statements->isPolyphonic())
663 return true;
664 return false;
665 }
666
667 // void Case::addBranch(IntExprRef condition, StatementsRef statements) {
668 // CaseBranchRef b = new CaseBranchRef;
669 // b->from = condition;
670 // b->statements = statements;
671 // branches.push_back(b);
672 // }
673 //
674 // void Case::addBranch(IntExprRef from, IntExprRef to, StatementsRef statements) {
675 // CaseBranchRef b = new CaseBranchRef;
676 // b->from = from;
677 // b->to = to;
678 // b->statements = statements;
679 // branches.push_back(b);
680 // }
681 //
682 // void Case::addBranch(CaseBranchRef branch) {
683 // branches.push_back(branch);
684 // }
685
686 void While::dump(int level) {
687 printIndents(level);
688 if (m_condition)
689 if (m_condition->isConstExpr())
690 printf("while (%d) {\n", m_condition->evalInt());
691 else
692 printf("while ([runtime expr]) {\n");
693 else
694 printf("while ([INVALID]) {\n");
695 m_statements->dump(level+1);
696 printIndents(level);
697 printf("}\n");
698 }
699
700 Statements* While::statements() const {
701 return (m_statements) ? const_cast<Statements*>( &*m_statements ) : NULL;
702 }
703
704 bool While::evalLoopStartCondition() {
705 if (!m_condition) return false;
706 return m_condition->evalInt();
707 }
708
709 void Neg::dump(int level) {
710 printIndents(level);
711 printf("Negative Expr\n");
712 }
713
714 String ConcatString::evalStr() {
715 // temporaries required here to enforce the associative left (to right) order
716 // ( required for GCC and Visual Studio, see:
717 // http://stackoverflow.com/questions/25842902/why-stdstring-concatenation-operator-works-like-right-associative-one
718 // Personally I am not convinced that this is "not a bug" of the
719 // compiler/STL implementation and the allegedly underlying "function call"
720 // nature causing this is IMO no profound reason that the C++ language's
721 // "+" operator's left associativity is ignored. -- Christian, 2016-07-14 )
722 String l = lhs->evalCastToStr();
723 String r = rhs->evalCastToStr();
724 return l + r;
725 }
726
727 void ConcatString::dump(int level) {
728 printIndents(level);
729 printf("ConcatString(\n");
730 lhs->dump(level+1);
731 printIndents(level);
732 printf(",\n");
733 rhs->dump(level+1);
734 printIndents(level);
735 printf(")");
736 }
737
738 bool ConcatString::isConstExpr() const {
739 return lhs->isConstExpr() && rhs->isConstExpr();
740 }
741
742 int Relation::evalInt() {
743 switch (type) {
744 case LESS_THAN:
745 return lhs->evalInt() < rhs->evalInt();
746 case GREATER_THAN:
747 return lhs->evalInt() > rhs->evalInt();
748 case LESS_OR_EQUAL:
749 return lhs->evalInt() <= rhs->evalInt();
750 case GREATER_OR_EQUAL:
751 return lhs->evalInt() >= rhs->evalInt();
752 case EQUAL:
753 if (lhs->exprType() == STRING_EXPR || rhs->exprType() == STRING_EXPR)
754 return lhs->evalCastToStr() == rhs->evalCastToStr();
755 else
756 return lhs->evalInt() == rhs->evalInt();
757 case NOT_EQUAL:
758 if (lhs->exprType() == STRING_EXPR || rhs->exprType() == STRING_EXPR)
759 return lhs->evalCastToStr() != rhs->evalCastToStr();
760 else
761 return lhs->evalInt() != rhs->evalInt();
762 }
763 return 0;
764 }
765
766 void Relation::dump(int level) {
767 printIndents(level);
768 printf("Relation(\n");
769 lhs->dump(level+1);
770 printIndents(level);
771 switch (type) {
772 case LESS_THAN:
773 printf("LESS_THAN\n");
774 break;
775 case GREATER_THAN:
776 printf("GREATER_THAN\n");
777 break;
778 case LESS_OR_EQUAL:
779 printf("LESS_OR_EQUAL\n");
780 break;
781 case GREATER_OR_EQUAL:
782 printf("GREATER_OR_EQUAL\n");
783 break;
784 case EQUAL:
785 printf("EQUAL\n");
786 break;
787 case NOT_EQUAL:
788 printf("NOT_EQUAL\n");
789 break;
790 }
791 rhs->dump(level+1);
792 printIndents(level);
793 printf(")\n");
794 }
795
796 bool Relation::isConstExpr() const {
797 return lhs->isConstExpr() && rhs->isConstExpr();
798 }
799
800 int Or::evalInt() {
801 IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
802 if (pLHS->evalInt()) return 1;
803 IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
804 return (pRHS->evalInt()) ? 1 : 0;
805 }
806
807 void Or::dump(int level) {
808 printIndents(level);
809 printf("Or(\n");
810 lhs->dump(level+1);
811 printIndents(level);
812 printf(",\n");
813 rhs->dump(level+1);
814 printIndents(level);
815 printf(")\n");
816 }
817
818 int BitwiseOr::evalInt() {
819 IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
820 IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
821 return pLHS->evalInt() | pRHS->evalInt();
822 }
823
824 void BitwiseOr::dump(int level) {
825 printIndents(level);
826 printf("BitwiseOr(\n");
827 lhs->dump(level+1);
828 printIndents(level);
829 printf(",\n");
830 rhs->dump(level+1);
831 printIndents(level);
832 printf(")\n");
833 }
834
835 int And::evalInt() {
836 IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
837 if (!pLHS->evalInt()) return 0;
838 IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
839 return (pRHS->evalInt()) ? 1 : 0;
840 }
841
842 void And::dump(int level) {
843 printIndents(level);
844 printf("And(\n");
845 lhs->dump(level+1);
846 printIndents(level);
847 printf(",\n");
848 rhs->dump(level+1);
849 printIndents(level);
850 printf(")\n");
851 }
852
853 int BitwiseAnd::evalInt() {
854 IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
855 IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
856 return pLHS->evalInt() & pRHS->evalInt();
857 }
858
859 void BitwiseAnd::dump(int level) {
860 printIndents(level);
861 printf("BitwiseAnd(\n");
862 lhs->dump(level+1);
863 printIndents(level);
864 printf(",\n");
865 rhs->dump(level+1);
866 printIndents(level);
867 printf(")\n");
868 }
869
870 void Not::dump(int level) {
871 printIndents(level);
872 printf("Not(\n");
873 expr->dump(level+1);
874 printIndents(level);
875 printf(")\n");
876 }
877
878 void BitwiseNot::dump(int level) {
879 printIndents(level);
880 printf("BitwiseNot(\n");
881 expr->dump(level+1);
882 printIndents(level);
883 printf(")\n");
884 }
885
886 StatementsRef ParserContext::userFunctionByName(const String& name) {
887 if (!userFnTable.count(name)) {
888 return StatementsRef();
889 }
890 return userFnTable.find(name)->second;
891 }
892
893 VariableRef ParserContext::variableByName(const String& name) {
894 if (!vartable.count(name)) {
895 return VariableRef();
896 }
897 return vartable.find(name)->second;
898 }
899
900 VariableRef ParserContext::globalVar(const String& name) {
901 if (!vartable.count(name)) {
902 //printf("No global var '%s'\n", name.c_str());
903 //for (std::map<String,VariableRef>::const_iterator it = vartable.begin(); it != vartable.end(); ++it)
904 // printf("-> var '%s'\n", it->first.c_str());
905 return VariableRef();
906 }
907 return vartable.find(name)->second;
908 }
909
910 IntVariableRef ParserContext::globalIntVar(const String& name) {
911 return globalVar(name);
912 }
913
914 StringVariableRef ParserContext::globalStrVar(const String& name) {
915 return globalVar(name);
916 }
917
918 ParserContext::~ParserContext() {
919 destroyScanner();
920 if (globalIntMemory) {
921 delete globalIntMemory;
922 globalIntMemory = NULL;
923 }
924 }
925
926 void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
927 ParserIssue e;
928 e.type = PARSER_ERROR;
929 e.txt = txt;
930 e.firstLine = firstLine;
931 e.lastLine = lastLine;
932 e.firstColumn = firstColumn;
933 e.lastColumn = lastColumn;
934 vErrors.push_back(e);
935 vIssues.push_back(e);
936 }
937
938 void ParserContext::addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
939 ParserIssue w;
940 w.type = PARSER_WARNING;
941 w.txt = txt;
942 w.firstLine = firstLine;
943 w.lastLine = lastLine;
944 w.firstColumn = firstColumn;
945 w.lastColumn = lastColumn;
946 vWarnings.push_back(w);
947 vIssues.push_back(w);
948 }
949
950 bool ParserContext::setPreprocessorCondition(const char* name) {
951 if (builtinPreprocessorConditions.count(name)) return false;
952 if (userPreprocessorConditions.count(name)) return false;
953 userPreprocessorConditions.insert(name);
954 return true;
955 }
956
957 bool ParserContext::resetPreprocessorCondition(const char* name) {
958 if (builtinPreprocessorConditions.count(name)) return false;
959 if (!userPreprocessorConditions.count(name)) return false;
960 userPreprocessorConditions.erase(name);
961 return true;
962 }
963
964 bool ParserContext::isPreprocessorConditionSet(const char* name) {
965 if (builtinPreprocessorConditions.count(name)) return true;
966 return userPreprocessorConditions.count(name);
967 }
968
969 std::vector<ParserIssue> ParserContext::issues() const {
970 return vIssues;
971 }
972
973 std::vector<ParserIssue> ParserContext::errors() const {
974 return vErrors;
975 }
976
977 std::vector<ParserIssue> ParserContext::warnings() const {
978 return vWarnings;
979 }
980
981 VMEventHandler* ParserContext::eventHandler(uint index) {
982 if (!handlers) return NULL;
983 return handlers->eventHandler(index);
984 }
985
986 VMEventHandler* ParserContext::eventHandlerByName(const String& name) {
987 if (!handlers) return NULL;
988 return handlers->eventHandlerByName(name);
989 }
990
991 void ParserContext::registerBuiltInConstIntVariables(const std::map<String,int>& vars) {
992 for (std::map<String,int>::const_iterator it = vars.begin();
993 it != vars.end(); ++it)
994 {
995 ConstIntVariableRef ref = new ConstIntVariable(it->second);
996 vartable[it->first] = ref;
997 }
998 }
999
1000 void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntRelPtr*>& vars) {
1001 for (std::map<String,VMIntRelPtr*>::const_iterator it = vars.begin();
1002 it != vars.end(); ++it)
1003 {
1004 BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);
1005 vartable[it->first] = ref;
1006 }
1007 }
1008
1009 void ParserContext::registerBuiltInIntArrayVariables(const std::map<String,VMInt8Array*>& vars) {
1010 for (std::map<String,VMInt8Array*>::const_iterator it = vars.begin();
1011 it != vars.end(); ++it)
1012 {
1013 BuiltInIntArrayVariableRef ref = new BuiltInIntArrayVariable(it->first, it->second);
1014 vartable[it->first] = ref;
1015 }
1016 }
1017
1018 void ParserContext::registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars) {
1019 for (std::map<String,VMDynVar*>::const_iterator it = vars.begin();
1020 it != vars.end(); ++it)
1021 {
1022 DynamicVariableCallRef ref = new DynamicVariableCall(it->first, this, it->second);
1023 vartable[it->first] = ref;
1024 }
1025 }
1026
1027 } // namespace LinuxSampler

  ViewVC Help
Powered by ViewVC