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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3034 - (hide 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 schoenebeck 2581 /*
2 schoenebeck 2935 * Copyright (c) 2014 - 2016 Christian Schoenebeck and Andreas Persson
3 schoenebeck 2581 *
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 schoenebeck 2588 #include <assert.h>
15 schoenebeck 2581
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 schoenebeck 2945 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 schoenebeck 2581 }
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 schoenebeck 2645 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 schoenebeck 2581 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 schoenebeck 2645 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 schoenebeck 2581 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 schoenebeck 2645 EventHandler::EventHandler(StatementsRef statements) {
216     this->statements = statements;
217     usingPolyphonics = statements->isPolyphonic();
218     }
219    
220 schoenebeck 2581 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 schoenebeck 2645 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 schoenebeck 2942 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 schoenebeck 2581 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 schoenebeck 2588 //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);
340     assert(ctx);
341 schoenebeck 2581 }
342    
343 schoenebeck 2588 inline static int postfixInc(int& object, int incBy) {
344     const int i = object;
345     object += incBy;
346     return i;
347     }
348    
349 schoenebeck 2581 IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)
350 schoenebeck 2588 : Variable(ctx, !ctx ? 0 : polyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) : postfixInc(ctx->globalIntVarCount, size), bConst),
351 schoenebeck 2581 polyphonic(polyphonic)
352     {
353 schoenebeck 2588 //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 schoenebeck 2581 }
359    
360     void IntVariable::assign(Expression* expr) {
361     IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
362 schoenebeck 3034 if (intExpr) {
363 schoenebeck 2581 if (polyphonic)
364     context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();
365     else
366     (*context->globalIntMemory)[memPos] = intExpr->evalInt();
367 schoenebeck 3034 }
368 schoenebeck 2581 }
369    
370     int IntVariable::evalInt() {
371     //printf("IntVariable::eval pos=%d\n", memPos);
372 schoenebeck 2588 if (polyphonic) {
373     //printf("evalInt() poly memPos=%d execCtx=0x%lx\n", memPos, (uint64_t)context->execContext);
374 schoenebeck 2581 return context->execContext->polyphonicIntMemory[memPos];
375 schoenebeck 2588 }
376 schoenebeck 2581 return (*context->globalIntMemory)[memPos];
377     }
378    
379     void IntVariable::dump(int level) {
380     printIndents(level);
381 schoenebeck 2945 printf("IntVariable\n");
382 schoenebeck 2588 //printf("IntVariable memPos=%d\n", memPos);
383 schoenebeck 2581 }
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 schoenebeck 2594 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 schoenebeck 2581 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 schoenebeck 2594 IntArrayVariable::IntArrayVariable(ParserContext* ctx, bool bConst)
459     : Variable(ctx, 0, bConst)
460     {
461     }
462    
463 schoenebeck 2581 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 schoenebeck 2594 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 schoenebeck 2581 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 schoenebeck 2645 bool If::isPolyphonic() const {
604     if (condition->isPolyphonic() || ifStatements->isPolyphonic())
605     return true;
606     return elseStatements ? elseStatements->isPolyphonic() : false;
607     }
608    
609 schoenebeck 2581 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 schoenebeck 2645 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 schoenebeck 2581 // 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 schoenebeck 2945 // temporaries required here to enforce the associative left (to right) order
716 schoenebeck 2948 // ( 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 schoenebeck 2945 String l = lhs->evalCastToStr();
723     String r = rhs->evalCastToStr();
724     return l + r;
725 schoenebeck 2581 }
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 schoenebeck 2611 if (pLHS->evalInt()) return 1;
803 schoenebeck 2581 IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
804 schoenebeck 2611 return (pRHS->evalInt()) ? 1 : 0;
805 schoenebeck 2581 }
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 schoenebeck 2935 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 schoenebeck 2581 int And::evalInt() {
836     IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
837 schoenebeck 2611 if (!pLHS->evalInt()) return 0;
838     IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
839     return (pRHS->evalInt()) ? 1 : 0;
840 schoenebeck 2581 }
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 schoenebeck 2935 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 schoenebeck 2581 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 schoenebeck 2935 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 schoenebeck 2951 StatementsRef ParserContext::userFunctionByName(const String& name) {
887     if (!userFnTable.count(name)) {
888     return StatementsRef();
889     }
890     return userFnTable.find(name)->second;
891     }
892    
893 schoenebeck 2581 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 schoenebeck 2588 ParserContext::~ParserContext() {
919     destroyScanner();
920     if (globalIntMemory) {
921     delete globalIntMemory;
922     globalIntMemory = NULL;
923     }
924     }
925    
926 schoenebeck 2889 void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
927 schoenebeck 2581 ParserIssue e;
928     e.type = PARSER_ERROR;
929     e.txt = txt;
930 schoenebeck 2889 e.firstLine = firstLine;
931     e.lastLine = lastLine;
932     e.firstColumn = firstColumn;
933     e.lastColumn = lastColumn;
934 schoenebeck 2588 vErrors.push_back(e);
935     vIssues.push_back(e);
936 schoenebeck 2581 }
937    
938 schoenebeck 2889 void ParserContext::addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
939 schoenebeck 2581 ParserIssue w;
940     w.type = PARSER_WARNING;
941     w.txt = txt;
942 schoenebeck 2889 w.firstLine = firstLine;
943     w.lastLine = lastLine;
944     w.firstColumn = firstColumn;
945     w.lastColumn = lastColumn;
946 schoenebeck 2588 vWarnings.push_back(w);
947     vIssues.push_back(w);
948 schoenebeck 2581 }
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 schoenebeck 2588 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 schoenebeck 2594 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 schoenebeck 2942 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 schoenebeck 2581 } // namespace LinuxSampler

  ViewVC Help
Powered by ViewVC