src/scriptvm/tree.cpp

/*
 * Copyright (c) 2014 Christian Schoenebeck and Andreas Persson
 *
 * http://www.linuxsampler.org
 *
 * This file is part of LinuxSampler and released under the same terms.
 * See README file for details.
 */

#include <cstdio>
#include <string.h>
#include "tree.h"
#include "../common/global_private.h"

namespace LinuxSampler {
    
bool isNoOperation(StatementRef statement) {
    NoOperation* noOp = dynamic_cast<NoOperation*>(&*statement);
    return noOp;
}
    
Node::Node() {
}

Node::~Node() {
}

void Node::printIndents(int n) {
    for (int i = 0; i < n; ++i) printf("  ");
    fflush(stdout);
}

String IntExpr::evalCastToStr() {
    return ToString(evalInt());
}

int IntLiteral::evalInt() {
    return value;
}

void IntLiteral::dump(int level) {
    printIndents(level);
    printf("IntLiteral %d\n", value);
}

void StringLiteral::dump(int level) {
    printIndents(level);
    printf("StringLiteral: '%s'\n", value.c_str());
}

int Add::evalInt() {
    IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
    IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
    return (pLHS && pRHS) ? pLHS->evalInt() + pRHS->evalInt() : 0;
}

void Add::dump(int level) {
    printIndents(level);
    printf("Add(\n");
    lhs->dump(level+1);
    printIndents(level);
    printf(",\n");
    rhs->dump(level+1);
    printIndents(level);
    printf(")\n");
}

int Sub::evalInt() {
    IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
    IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
    return (pLHS && pRHS) ? pLHS->evalInt() - pRHS->evalInt() : 0;
}

void Sub::dump(int level) {
    printIndents(level);
    printf("Sub(\n");
    lhs->dump(level+1);
    printIndents(level);
    printf(",\n");
    rhs->dump(level+1);
    printIndents(level);
    printf(")\n");
}

int Mul::evalInt() {
    IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
    IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
    return (pLHS && pRHS) ? pLHS->evalInt() * pRHS->evalInt() : 0;
}

void Mul::dump(int level) {
    printIndents(level);
    printf("Mul(\n");
    lhs->dump(level+1);
    printIndents(level);
    printf(",\n");
    rhs->dump(level+1);
    printIndents(level);
    printf(")\n");
}

int Div::evalInt() {
    IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
    IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
    return (pLHS && pRHS) ? pRHS->evalInt() == 0 ? 0 : pLHS->evalInt() / pRHS->evalInt() : 0;
}

void Div::dump(int level) {
    printIndents(level);
    printf("Div(\n");
    lhs->dump(level+1);
    printIndents(level);
    printf(",\n");
    rhs->dump(level+1);
    printIndents(level);
    printf(")\n");
}

int Mod::evalInt() {
    IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
    IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
    return (pLHS && pRHS) ? pLHS->evalInt() % pRHS->evalInt() : 0;
}

void Mod::dump(int level) {
    printIndents(level);
    printf("Mod(\n");
    lhs->dump(level+1);
    printIndents(level);
    printf(",\n");
    rhs->dump(level+1);
    printIndents(level);
    printf(")\n");
}

void Args::dump(int level) {
    printIndents(level);
    printf("Args(\n");
    for (std::vector<ExpressionRef>::iterator it = args.begin() ; it != args.end() ; ++it) {
        (*it)->dump(level+1);
    }
    printIndents(level);
    printf(")\n");
}

EventHandlers::EventHandlers() {
    //printf("EventHandlers::Constructor 0x%lx\n", (long long)this);
}

EventHandlers::~EventHandlers() {
}

void EventHandlers::add(EventHandlerRef arg) {
    args.push_back(arg);
}

void EventHandlers::dump(int level) {
    printIndents(level);
    printf("EventHandlers {\n");
    for (std::vector<EventHandlerRef>::iterator it = args.begin() ; it != args.end() ; ++it) {
        (*it)->dump(level+1);
    }
    printIndents(level);
    printf("}\n");
}

EventHandler* EventHandlers::eventHandlerByName(const String& name) const {
    for (int i = 0; i < args.size(); ++i)
        if (args.at(i)->eventHandlerName() == name)
            return const_cast<EventHandler*>(&*args.at(i));
    return NULL;
}

EventHandler* EventHandlers::eventHandler(uint index) const {
    if (index >= args.size()) return NULL;
    return const_cast<EventHandler*>(&*args.at(index));
}

Assignment::Assignment(VariableRef variable, ExpressionRef value)
   : variable(variable), value(value)
{
}

void Assignment::dump(int level) {
    printIndents(level);
    printf("Assignment\n");
}

StmtFlags_t Assignment::exec() {
    if (!variable)
        return StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
    variable->assign(&*value);
    return STMT_SUCCESS;
}

void EventHandler::dump(int level) {
    printIndents(level);
    printf("EventHandler {\n");
    statements->dump(level+1);
    printIndents(level);
    printf("}\n");
}

void Statements::dump(int level) {
    printIndents(level);
    printf("Statements {\n");
    for (std::vector<StatementRef>::iterator it = args.begin() ; it != args.end() ; ++it) {
        (*it)->dump(level+1);
    }
    printIndents(level);
    printf("}\n");
}

Statement* Statements::statement(uint i) {
    if (i >= args.size()) return NULL;
    return &*args.at(i);
}

void FunctionCall::dump(int level) {
    printIndents(level);
    printf("FunctionCall '%s' args={\n", functionName.c_str());
    args->dump(level+1);
    printIndents(level);
    printf("}\n");
}

ExprType_t FunctionCall::exprType() const {
    if (!fn) return EMPTY_EXPR;
    return fn->returnType();
}

VMFnResult* FunctionCall::execVMFn() {
    if (!fn) return NULL;
    // assuming here that all argument checks (amount and types) have been made
    // at parse time, to avoid time intensive checks on each function call
    return fn->exec(dynamic_cast<VMFnArgs*>(&*args));
}

StmtFlags_t FunctionCall::exec() {
    VMFnResult* result = execVMFn();
    if (!result)
        return StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
    return result->resultFlags();
}

int FunctionCall::evalInt() {
    VMFnResult* result = execVMFn();
    if (!result) return 0;
    VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
    if (!intExpr) return 0;
    return intExpr->evalInt();
}

String FunctionCall::evalStr() {
    VMFnResult* result = execVMFn();
    if (!result) return "";
    VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());
    if (!strExpr) return "";
    return strExpr->evalStr();
}

String FunctionCall::evalCastToStr() {
    VMFnResult* result = execVMFn();
    if (!result) return "";
    if (result->resultValue()->exprType() == STRING_EXPR) {
        VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());
        return strExpr ? strExpr->evalStr() : "";
    } else {
        VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
        return intExpr ? ToString(intExpr->evalInt()) : "";
    }
}

IntVariable::IntVariable(ParserContext* ctx)
    : Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false), polyphonic(false)
{
}

IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)
    : Variable(ctx, !ctx ? 0 : polyphonic ? ctx->polyphonicIntVarCount += size : ctx->globalIntVarCount += size, bConst),
      polyphonic(polyphonic)
{
}

void IntVariable::assign(Expression* expr) {
    IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
    if (intExpr)
        if (polyphonic)
            context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();
        else
            (*context->globalIntMemory)[memPos] = intExpr->evalInt();
}

int IntVariable::evalInt() {
    //printf("IntVariable::eval pos=%d\n", memPos);
    if (polyphonic)
        return context->execContext->polyphonicIntMemory[memPos];
    return (*context->globalIntMemory)[memPos];
}

void IntVariable::dump(int level) {
    printIndents(level);
    printf("IntVariable memPos=%d\n", memPos);
}

//ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)
ConstIntVariable::ConstIntVariable(int value)
    : IntVariable(NULL,false,true), value(value)
{
}

void ConstIntVariable::assign(Expression* expr) {
    // ignore assignment
/*
    printf("ConstIntVariable::assign()\n");
    IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
    if (intExpr) {
        value = intExpr->evalInt();
    }
*/
}

int ConstIntVariable::evalInt() {
    return value;
}

void ConstIntVariable::dump(int level) {
    printIndents(level);
    printf("ConstIntVariable val=%d\n", value);
}

PolyphonicIntVariable::PolyphonicIntVariable(ParserContext* ctx)
    : IntVariable(ctx,true,false)
{
}

void PolyphonicIntVariable::dump(int level) {
    printIndents(level);
    printf("PolyphonicIntVariable\n");
}

IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size)
    : Variable(ctx, 0, false)
{
    values.resize(size);
    memset(&values[0], 0, size * sizeof(int));
}

IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size, ArgsRef values)
    : Variable(ctx, 0, false)
{
    this->values.resize(size);
    for (int i = 0; i < values->argsCount(); ++i) {
        VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));
        if (expr) this->values[i] = expr->evalInt();
    }
}

int IntArrayVariable::evalIntElement(uint i) {
    if (i >= values.size()) return 0;
    return values[i];
}

void IntArrayVariable::assignIntElement(uint i, int value) {
    if (i >= values.size()) return;
    values[i] = value;
}

void IntArrayVariable::dump(int level) {
    printIndents(level);
    printf("IntArray(");
    for (int i = 0; i < values.size(); ++i) {
        if (i % 12 == 0) {
            printf("\n");
            printIndents(level+1);
        }
        printf("%d, ", values[i]);
    }
    printIndents(level);
    printf(")\n");
}

IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)
    : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)
{    
}

void IntArrayElement::assign(Expression* expr) {
    IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
    if (!valueExpr) return;
    int value = valueExpr->evalInt();

    if (!index) return;
    int idx = index->evalInt();
    if (idx < 0 || idx >= array->arraySize()) return;

    array->assignIntElement(idx, value);
}

int IntArrayElement::evalInt() {
    if (!index) return 0;
    int idx = index->evalInt();
    if (idx < 0 || idx >= array->arraySize()) return 0;

    return array->evalIntElement(idx);
}

void IntArrayElement::dump(int level) {
    printIndents(level);
    printf("IntArrayElement\n");
}

StringVariable::StringVariable(ParserContext* ctx)
    : Variable(ctx,ctx->globalStrVarCount++,false)
{
}

StringVariable::StringVariable(ParserContext* ctx, bool bConst)
    : Variable(ctx,0,bConst)
{
}

void StringVariable::assign(Expression* expr) {
    StringExpr* strExpr = dynamic_cast<StringExpr*>(expr);
    (*context->globalStrMemory)[memPos] = strExpr->evalStr();
}

String StringVariable::evalStr() {
    //printf("StringVariable::eval pos=%d\n", memPos);
    return (*context->globalStrMemory)[memPos];
}

void StringVariable::dump(int level) {
    printIndents(level);
    printf("StringVariable memPos=%d\n", memPos);
}

ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)
    : StringVariable(ctx,true), value(_value)
{
}

void ConstStringVariable::assign(Expression* expr) {
    // ignore assignment
//     StringExpr* strExpr = dynamic_cast<StringExpr*>(expr);
//     if (strExpr) value = strExpr->evalStr();
}

String ConstStringVariable::evalStr() {
    return value;
}

void ConstStringVariable::dump(int level) {
    printIndents(level);
    printf("ConstStringVariable val='%s'\n", value.c_str());
}

void If::dump(int level) {
    printIndents(level);
    if (ifStatements && elseStatements)
        printf("if cond stmts1 else stmts2 end if\n");
    else if (ifStatements)
        printf("if cond statements end if\n");
    else
        printf("if [INVALID]\n");
}

int If::evalBranch() {
    if (condition->evalInt()) return 0;
    if (elseStatements) return 1;
    return -1;
}

Statements* If::branch(uint i) const {
    if (i == 0) return (Statements*) &*ifStatements;
    if (i == 1) return (elseStatements) ? (Statements*) &*elseStatements : NULL;
    return NULL;
}

void SelectCase::dump(int level) {
    printIndents(level);
    if (select)
        if (select->isConstExpr())
            printf("Case select %d\n", select->evalInt());
        else
            printf("Case select [runtime expr]\n");
    else
        printf("Case select NULL\n");
    for (int i = 0; i < branches.size(); ++i) {
        printIndents(level+1);
        CaseBranch& branch = branches[i];
        if (branch.from && branch.to)
            if (branch.from->isConstExpr() && branch.to->isConstExpr())
                printf("case %d to %d\n", branch.from->evalInt(), branch.to->evalInt());
            else if (branch.from->isConstExpr() && !branch.to->isConstExpr())
                printf("case %d to [runtime expr]\n", branch.from->evalInt());
            else if (!branch.from->isConstExpr() && branch.to->isConstExpr())
                printf("case [runtime expr] to %d\n", branch.to->evalInt());
            else
                printf("case [runtime expr] to [runtime expr]\n");
        else if (branch.from)
            if (branch.from->isConstExpr())
                printf("case %d\n", branch.from->evalInt());
            else
                printf("case [runtime expr]\n");
        else
            printf("case NULL\n");
    }
}

int SelectCase::evalBranch() {
    int value = select->evalInt();
    for (int i = 0; i < branches.size(); ++i) {
        if (branches.at(i).from && branches.at(i).to) { // i.e. "case 4 to 7" ...
            if (branches.at(i).from->evalInt() <= value &&
                branches.at(i).to->evalInt() >= value) return i;
        } else { // i.e. "case 5" ...
            if (branches.at(i).from->evalInt() == value) return i;
        }
    }
    return -1;
}

Statements* SelectCase::branch(uint i) const {
    if (i < branches.size())
        return const_cast<Statements*>( &*branches[i].statements );
    return NULL;
}

// void Case::addBranch(IntExprRef condition, StatementsRef statements) {
//     CaseBranchRef b = new CaseBranchRef;
//     b->from = condition;
//     b->statements = statements;
//     branches.push_back(b);
// }
// 
// void Case::addBranch(IntExprRef from, IntExprRef to, StatementsRef statements) {
//     CaseBranchRef b = new CaseBranchRef;
//     b->from = from;
//     b->to   = to;
//     b->statements = statements;
//     branches.push_back(b);
// }
// 
// void Case::addBranch(CaseBranchRef branch) {
//     branches.push_back(branch);
// }

void While::dump(int level) {
    printIndents(level);
    if (m_condition)
        if (m_condition->isConstExpr())
            printf("while (%d) {\n", m_condition->evalInt());
        else
            printf("while ([runtime expr]) {\n");
    else
        printf("while ([INVALID]) {\n");
    m_statements->dump(level+1);
    printIndents(level);
    printf("}\n");
}

Statements* While::statements() const {
    return (m_statements) ? const_cast<Statements*>( &*m_statements ) : NULL;
}

bool While::evalLoopStartCondition() {
    if (!m_condition) return false;
    return m_condition->evalInt();
}

void Neg::dump(int level) {
    printIndents(level);
    printf("Negative Expr\n");
}

String ConcatString::evalStr() {
    return lhs->evalCastToStr() + rhs->evalCastToStr();
}

void ConcatString::dump(int level) {
    printIndents(level);
    printf("ConcatString(\n");
    lhs->dump(level+1);
    printIndents(level);
    printf(",\n");
    rhs->dump(level+1);
    printIndents(level);
    printf(")");
}

bool ConcatString::isConstExpr() const {
    return lhs->isConstExpr() && rhs->isConstExpr();
}

int Relation::evalInt() {
    switch (type) {
        case LESS_THAN:
            return lhs->evalInt() < rhs->evalInt();
        case GREATER_THAN:
            return lhs->evalInt() > rhs->evalInt();
        case LESS_OR_EQUAL:
            return lhs->evalInt() <= rhs->evalInt();
        case GREATER_OR_EQUAL:
            return lhs->evalInt() >= rhs->evalInt();
        case EQUAL:
            if (lhs->exprType() == STRING_EXPR || rhs->exprType() == STRING_EXPR)
                return lhs->evalCastToStr() == rhs->evalCastToStr();
            else
                return lhs->evalInt() == rhs->evalInt();
        case NOT_EQUAL:
            if (lhs->exprType() == STRING_EXPR || rhs->exprType() == STRING_EXPR)
                return lhs->evalCastToStr() != rhs->evalCastToStr();
            else
                return lhs->evalInt() != rhs->evalInt();
    }
    return 0;
}

void Relation::dump(int level) {
    printIndents(level);
    printf("Relation(\n");
    lhs->dump(level+1);
    printIndents(level);
    switch (type) {
        case LESS_THAN:
            printf("LESS_THAN\n");
            break;
        case GREATER_THAN:
            printf("GREATER_THAN\n");
            break;
        case LESS_OR_EQUAL:
            printf("LESS_OR_EQUAL\n");
            break;
        case GREATER_OR_EQUAL:
            printf("GREATER_OR_EQUAL\n");
            break;
        case EQUAL:
            printf("EQUAL\n");
            break;
        case NOT_EQUAL:
            printf("NOT_EQUAL\n");
            break;
    }
    rhs->dump(level+1);
    printIndents(level);
    printf(")\n");
}

bool Relation::isConstExpr() const {
    return lhs->isConstExpr() && rhs->isConstExpr();
}

int Or::evalInt() {
    IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
    IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
    return pLHS->evalInt() || pRHS->evalInt();
}

void Or::dump(int level) {
    printIndents(level);
    printf("Or(\n");
    lhs->dump(level+1);
    printIndents(level);
    printf(",\n");
    rhs->dump(level+1);
    printIndents(level);
    printf(")\n");
}

int And::evalInt() {
    IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
    IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
    return pLHS->evalInt() && pRHS->evalInt();
}

void And::dump(int level) {
    printIndents(level);
    printf("And(\n");
    lhs->dump(level+1);
    printIndents(level);
    printf(",\n");
    rhs->dump(level+1);
    printIndents(level);
    printf(")\n");
}

void Not::dump(int level) {
    printIndents(level);
    printf("Not(\n");
    expr->dump(level+1);
    printIndents(level);
    printf(")\n");
}

VariableRef ParserContext::variableByName(const String& name) {
    if (!vartable.count(name)) {
        return VariableRef();
    }
    return vartable.find(name)->second;
}

VariableRef ParserContext::globalVar(const String& name) {
    if (!vartable.count(name)) {
        //printf("No global var '%s'\n", name.c_str());
        //for (std::map<String,VariableRef>::const_iterator it = vartable.begin(); it != vartable.end(); ++it)
        //    printf("-> var '%s'\n", it->first.c_str());
        return VariableRef();
    }
    return vartable.find(name)->second;
}

IntVariableRef ParserContext::globalIntVar(const String& name) {
    return globalVar(name);
}

StringVariableRef ParserContext::globalStrVar(const String& name) {
    return globalVar(name);
}

void ParserContext::addErr(int line, const char* txt) {
    ParserIssue e;
    e.type = PARSER_ERROR;
    e.txt = txt;
    e.line = line;
    errors.push_back(e);
    issues.push_back(e);
}

void ParserContext::addWrn(int line, const char* txt) {
    ParserIssue w;
    w.type = PARSER_WARNING;
    w.txt = txt;
    w.line = line;
    warnings.push_back(w);
    issues.push_back(w);
}

bool ParserContext::setPreprocessorCondition(const char* name) {
    if (builtinPreprocessorConditions.count(name)) return false;
    if (userPreprocessorConditions.count(name)) return false;
    userPreprocessorConditions.insert(name);
    return true;
}

bool ParserContext::resetPreprocessorCondition(const char* name) {
    if (builtinPreprocessorConditions.count(name)) return false;
    if (!userPreprocessorConditions.count(name)) return false;
    userPreprocessorConditions.erase(name);
    return true;
}

bool ParserContext::isPreprocessorConditionSet(const char* name) {
    if (builtinPreprocessorConditions.count(name)) return true;
    return userPreprocessorConditions.count(name);
}

} // namespace LinuxSampler
1	schoenebeck	2581	/*
2			* Copyright (c) 2014 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
15			namespace LinuxSampler {
16
17			bool isNoOperation(StatementRef statement) {
18			NoOperation* noOp = dynamic_cast<NoOperation>(&statement);
19			return noOp;
20			}
21
22			Node::Node() {
23			}
24
25			Node::~Node() {
26			}
27
28			void Node::printIndents(int n) {
29			for (int i = 0; i < n; ++i) printf(" ");
30			fflush(stdout);
31			}
32
33			String IntExpr::evalCastToStr() {
34			return ToString(evalInt());
35			}
36
37			int IntLiteral::evalInt() {
38			return value;
39			}
40
41			void IntLiteral::dump(int level) {
42			printIndents(level);
43			printf("IntLiteral %d\n", value);
44			}
45
46			void StringLiteral::dump(int level) {
47			printIndents(level);
48			printf("StringLiteral: '%s'\n", value.c_str());
49			}
50
51			int Add::evalInt() {
52			IntExpr* pLHS = dynamic_cast<IntExpr>(&lhs);
53			IntExpr* pRHS = dynamic_cast<IntExpr>(&rhs);;
54			return (pLHS && pRHS) ? pLHS->evalInt() + pRHS->evalInt() : 0;
55			}
56
57			void Add::dump(int level) {
58			printIndents(level);
59			printf("Add(\n");
60			lhs->dump(level+1);
61			printIndents(level);
62			printf(",\n");
63			rhs->dump(level+1);
64			printIndents(level);
65			printf(")\n");
66			}
67
68			int Sub::evalInt() {
69			IntExpr* pLHS = dynamic_cast<IntExpr>(&lhs);
70			IntExpr* pRHS = dynamic_cast<IntExpr>(&rhs);;
71			return (pLHS && pRHS) ? pLHS->evalInt() - pRHS->evalInt() : 0;
72			}
73
74			void Sub::dump(int level) {
75			printIndents(level);
76			printf("Sub(\n");
77			lhs->dump(level+1);
78			printIndents(level);
79			printf(",\n");
80			rhs->dump(level+1);
81			printIndents(level);
82			printf(")\n");
83			}
84
85			int Mul::evalInt() {
86			IntExpr* pLHS = dynamic_cast<IntExpr>(&lhs);
87			IntExpr* pRHS = dynamic_cast<IntExpr>(&rhs);;
88			return (pLHS && pRHS) ? pLHS->evalInt() * pRHS->evalInt() : 0;
89			}
90
91			void Mul::dump(int level) {
92			printIndents(level);
93			printf("Mul(\n");
94			lhs->dump(level+1);
95			printIndents(level);
96			printf(",\n");
97			rhs->dump(level+1);
98			printIndents(level);
99			printf(")\n");
100			}
101
102			int Div::evalInt() {
103			IntExpr* pLHS = dynamic_cast<IntExpr>(&lhs);
104			IntExpr* pRHS = dynamic_cast<IntExpr>(&rhs);;
105			return (pLHS && pRHS) ? pRHS->evalInt() == 0 ? 0 : pLHS->evalInt() / pRHS->evalInt() : 0;
106			}
107
108			void Div::dump(int level) {
109			printIndents(level);
110			printf("Div(\n");
111			lhs->dump(level+1);
112			printIndents(level);
113			printf(",\n");
114			rhs->dump(level+1);
115			printIndents(level);
116			printf(")\n");
117			}
118
119			int Mod::evalInt() {
120			IntExpr* pLHS = dynamic_cast<IntExpr>(&lhs);
121			IntExpr* pRHS = dynamic_cast<IntExpr>(&rhs);;
122			return (pLHS && pRHS) ? pLHS->evalInt() % pRHS->evalInt() : 0;
123			}
124
125			void Mod::dump(int level) {
126			printIndents(level);
127			printf("Mod(\n");
128			lhs->dump(level+1);
129			printIndents(level);
130			printf(",\n");
131			rhs->dump(level+1);
132			printIndents(level);
133			printf(")\n");
134			}
135
136			void Args::dump(int level) {
137			printIndents(level);
138			printf("Args(\n");
139			for (std::vector<ExpressionRef>::iterator it = args.begin() ; it != args.end() ; ++it) {
140			(*it)->dump(level+1);
141			}
142			printIndents(level);
143			printf(")\n");
144			}
145
146			EventHandlers::EventHandlers() {
147			//printf("EventHandlers::Constructor 0x%lx\n", (long long)this);
148			}
149
150			EventHandlers::~EventHandlers() {
151			}
152
153			void EventHandlers::add(EventHandlerRef arg) {
154			args.push_back(arg);
155			}
156
157			void EventHandlers::dump(int level) {
158			printIndents(level);
159			printf("EventHandlers {\n");
160			for (std::vector<EventHandlerRef>::iterator it = args.begin() ; it != args.end() ; ++it) {
161			(*it)->dump(level+1);
162			}
163			printIndents(level);
164			printf("}\n");
165			}
166
167			EventHandler* EventHandlers::eventHandlerByName(const String& name) const {
168			for (int i = 0; i < args.size(); ++i)
169			if (args.at(i)->eventHandlerName() == name)
170			return const_cast<EventHandler>(&args.at(i));
171			return NULL;
172			}
173
174			EventHandler* EventHandlers::eventHandler(uint index) const {
175			if (index >= args.size()) return NULL;
176			return const_cast<EventHandler>(&args.at(index));
177			}
178
179			Assignment::Assignment(VariableRef variable, ExpressionRef value)
180			: variable(variable), value(value)
181			{
182			}
183
184			void Assignment::dump(int level) {
185			printIndents(level);
186			printf("Assignment\n");
187			}
188
189			StmtFlags_t Assignment::exec() {
190			if (!variable)
191			return StmtFlags_t(STMT_ABORT_SIGNALLED \| STMT_ERROR_OCCURRED);
192			variable->assign(&*value);
193			return STMT_SUCCESS;
194			}
195
196			void EventHandler::dump(int level) {
197			printIndents(level);
198			printf("EventHandler {\n");
199			statements->dump(level+1);
200			printIndents(level);
201			printf("}\n");
202			}
203
204			void Statements::dump(int level) {
205			printIndents(level);
206			printf("Statements {\n");
207			for (std::vector<StatementRef>::iterator it = args.begin() ; it != args.end() ; ++it) {
208			(*it)->dump(level+1);
209			}
210			printIndents(level);
211			printf("}\n");
212			}
213
214			Statement* Statements::statement(uint i) {
215			if (i >= args.size()) return NULL;
216			return &*args.at(i);
217			}
218
219			void FunctionCall::dump(int level) {
220			printIndents(level);
221			printf("FunctionCall '%s' args={\n", functionName.c_str());
222			args->dump(level+1);
223			printIndents(level);
224			printf("}\n");
225			}
226
227			ExprType_t FunctionCall::exprType() const {
228			if (!fn) return EMPTY_EXPR;
229			return fn->returnType();
230			}
231
232			VMFnResult* FunctionCall::execVMFn() {
233			if (!fn) return NULL;
234			// assuming here that all argument checks (amount and types) have been made
235			// at parse time, to avoid time intensive checks on each function call
236			return fn->exec(dynamic_cast<VMFnArgs>(&args));
237			}
238
239			StmtFlags_t FunctionCall::exec() {
240			VMFnResult* result = execVMFn();
241			if (!result)
242			return StmtFlags_t(STMT_ABORT_SIGNALLED \| STMT_ERROR_OCCURRED);
243			return result->resultFlags();
244			}
245
246			int FunctionCall::evalInt() {
247			VMFnResult* result = execVMFn();
248			if (!result) return 0;
249			VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
250			if (!intExpr) return 0;
251			return intExpr->evalInt();
252			}
253
254			String FunctionCall::evalStr() {
255			VMFnResult* result = execVMFn();
256			if (!result) return "";
257			VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());
258			if (!strExpr) return "";
259			return strExpr->evalStr();
260			}
261
262			String FunctionCall::evalCastToStr() {
263			VMFnResult* result = execVMFn();
264			if (!result) return "";
265			if (result->resultValue()->exprType() == STRING_EXPR) {
266			VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());
267			return strExpr ? strExpr->evalStr() : "";
268			} else {
269			VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
270			return intExpr ? ToString(intExpr->evalInt()) : "";
271			}
272			}
273
274			IntVariable::IntVariable(ParserContext* ctx)
275			: Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false), polyphonic(false)
276			{
277			}
278
279			IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)
280			: Variable(ctx, !ctx ? 0 : polyphonic ? ctx->polyphonicIntVarCount += size : ctx->globalIntVarCount += size, bConst),
281			polyphonic(polyphonic)
282			{
283			}
284
285			void IntVariable::assign(Expression* expr) {
286			IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
287			if (intExpr)
288			if (polyphonic)
289			context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();
290			else
291			(*context->globalIntMemory)[memPos] = intExpr->evalInt();
292			}
293
294			int IntVariable::evalInt() {
295			//printf("IntVariable::eval pos=%d\n", memPos);
296			if (polyphonic)
297			return context->execContext->polyphonicIntMemory[memPos];
298			return (*context->globalIntMemory)[memPos];
299			}
300
301			void IntVariable::dump(int level) {
302			printIndents(level);
303			printf("IntVariable memPos=%d\n", memPos);
304			}
305
306			//ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)
307			ConstIntVariable::ConstIntVariable(int value)
308			: IntVariable(NULL,false,true), value(value)
309			{
310			}
311
312			void ConstIntVariable::assign(Expression* expr) {
313			// ignore assignment
314			/*
315			printf("ConstIntVariable::assign()\n");
316			IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
317			if (intExpr) {
318			value = intExpr->evalInt();
319			}
320			*/
321			}
322
323			int ConstIntVariable::evalInt() {
324			return value;
325			}
326
327			void ConstIntVariable::dump(int level) {
328			printIndents(level);
329			printf("ConstIntVariable val=%d\n", value);
330			}
331
332			PolyphonicIntVariable::PolyphonicIntVariable(ParserContext* ctx)
333			: IntVariable(ctx,true,false)
334			{
335			}
336
337			void PolyphonicIntVariable::dump(int level) {
338			printIndents(level);
339			printf("PolyphonicIntVariable\n");
340			}
341
342			IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size)
343			: Variable(ctx, 0, false)
344			{
345			values.resize(size);
346			memset(&values[0], 0, size * sizeof(int));
347			}
348
349			IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size, ArgsRef values)
350			: Variable(ctx, 0, false)
351			{
352			this->values.resize(size);
353			for (int i = 0; i < values->argsCount(); ++i) {
354			VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));
355			if (expr) this->values[i] = expr->evalInt();
356			}
357			}
358
359			int IntArrayVariable::evalIntElement(uint i) {
360			if (i >= values.size()) return 0;
361			return values[i];
362			}
363
364			void IntArrayVariable::assignIntElement(uint i, int value) {
365			if (i >= values.size()) return;
366			values[i] = value;
367			}
368
369			void IntArrayVariable::dump(int level) {
370			printIndents(level);
371			printf("IntArray(");
372			for (int i = 0; i < values.size(); ++i) {
373			if (i % 12 == 0) {
374			printf("\n");
375			printIndents(level+1);
376			}
377			printf("%d, ", values[i]);
378			}
379			printIndents(level);
380			printf(")\n");
381			}
382
383			IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)
384			: IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)
385			{
386			}
387
388			void IntArrayElement::assign(Expression* expr) {
389			IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
390			if (!valueExpr) return;
391			int value = valueExpr->evalInt();
392
393			if (!index) return;
394			int idx = index->evalInt();
395			if (idx < 0 \|\| idx >= array->arraySize()) return;
396
397			array->assignIntElement(idx, value);
398			}
399
400			int IntArrayElement::evalInt() {
401			if (!index) return 0;
402			int idx = index->evalInt();
403			if (idx < 0 \|\| idx >= array->arraySize()) return 0;
404
405			return array->evalIntElement(idx);
406			}
407
408			void IntArrayElement::dump(int level) {
409			printIndents(level);
410			printf("IntArrayElement\n");
411			}
412
413			StringVariable::StringVariable(ParserContext* ctx)
414			: Variable(ctx,ctx->globalStrVarCount++,false)
415			{
416			}
417
418			StringVariable::StringVariable(ParserContext* ctx, bool bConst)
419			: Variable(ctx,0,bConst)
420			{
421			}
422
423			void StringVariable::assign(Expression* expr) {
424			StringExpr* strExpr = dynamic_cast<StringExpr*>(expr);
425			(*context->globalStrMemory)[memPos] = strExpr->evalStr();
426			}
427
428			String StringVariable::evalStr() {
429			//printf("StringVariable::eval pos=%d\n", memPos);
430			return (*context->globalStrMemory)[memPos];
431			}
432
433			void StringVariable::dump(int level) {
434			printIndents(level);
435			printf("StringVariable memPos=%d\n", memPos);
436			}
437
438			ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)
439			: StringVariable(ctx,true), value(_value)
440			{
441			}
442
443			void ConstStringVariable::assign(Expression* expr) {
444			// ignore assignment
445			// StringExpr* strExpr = dynamic_cast<StringExpr*>(expr);
446			// if (strExpr) value = strExpr->evalStr();
447			}
448
449			String ConstStringVariable::evalStr() {
450			return value;
451			}
452
453			void ConstStringVariable::dump(int level) {
454			printIndents(level);
455			printf("ConstStringVariable val='%s'\n", value.c_str());
456			}
457
458			void If::dump(int level) {
459			printIndents(level);
460			if (ifStatements && elseStatements)
461			printf("if cond stmts1 else stmts2 end if\n");
462			else if (ifStatements)
463			printf("if cond statements end if\n");
464			else
465			printf("if [INVALID]\n");
466			}
467
468			int If::evalBranch() {
469			if (condition->evalInt()) return 0;
470			if (elseStatements) return 1;
471			return -1;
472			}
473
474			Statements* If::branch(uint i) const {
475			if (i == 0) return (Statements) &ifStatements;
476			if (i == 1) return (elseStatements) ? (Statements) &elseStatements : NULL;
477			return NULL;
478			}
479
480			void SelectCase::dump(int level) {
481			printIndents(level);
482			if (select)
483			if (select->isConstExpr())
484			printf("Case select %d\n", select->evalInt());
485			else
486			printf("Case select [runtime expr]\n");
487			else
488			printf("Case select NULL\n");
489			for (int i = 0; i < branches.size(); ++i) {
490			printIndents(level+1);
491			CaseBranch& branch = branches[i];
492			if (branch.from && branch.to)
493			if (branch.from->isConstExpr() && branch.to->isConstExpr())
494			printf("case %d to %d\n", branch.from->evalInt(), branch.to->evalInt());
495			else if (branch.from->isConstExpr() && !branch.to->isConstExpr())
496			printf("case %d to [runtime expr]\n", branch.from->evalInt());
497			else if (!branch.from->isConstExpr() && branch.to->isConstExpr())
498			printf("case [runtime expr] to %d\n", branch.to->evalInt());
499			else
500			printf("case [runtime expr] to [runtime expr]\n");
501			else if (branch.from)
502			if (branch.from->isConstExpr())
503			printf("case %d\n", branch.from->evalInt());
504			else
505			printf("case [runtime expr]\n");
506			else
507			printf("case NULL\n");
508			}
509			}
510
511			int SelectCase::evalBranch() {
512			int value = select->evalInt();
513			for (int i = 0; i < branches.size(); ++i) {
514			if (branches.at(i).from && branches.at(i).to) { // i.e. "case 4 to 7" ...
515			if (branches.at(i).from->evalInt() <= value &&
516			branches.at(i).to->evalInt() >= value) return i;
517			} else { // i.e. "case 5" ...
518			if (branches.at(i).from->evalInt() == value) return i;
519			}
520			}
521			return -1;
522			}
523
524			Statements* SelectCase::branch(uint i) const {
525			if (i < branches.size())
526			return const_cast<Statements>( &branches[i].statements );
527			return NULL;
528			}
529
530			// void Case::addBranch(IntExprRef condition, StatementsRef statements) {
531			// CaseBranchRef b = new CaseBranchRef;
532			// b->from = condition;
533			// b->statements = statements;
534			// branches.push_back(b);
535			// }
536			//
537			// void Case::addBranch(IntExprRef from, IntExprRef to, StatementsRef statements) {
538			// CaseBranchRef b = new CaseBranchRef;
539			// b->from = from;
540			// b->to = to;
541			// b->statements = statements;
542			// branches.push_back(b);
543			// }
544			//
545			// void Case::addBranch(CaseBranchRef branch) {
546			// branches.push_back(branch);
547			// }
548
549			void While::dump(int level) {
550			printIndents(level);
551			if (m_condition)
552			if (m_condition->isConstExpr())
553			printf("while (%d) {\n", m_condition->evalInt());
554			else
555			printf("while ([runtime expr]) {\n");
556			else
557			printf("while ([INVALID]) {\n");
558			m_statements->dump(level+1);
559			printIndents(level);
560			printf("}\n");
561			}
562
563			Statements* While::statements() const {
564			return (m_statements) ? const_cast<Statements>( &m_statements ) : NULL;
565			}
566
567			bool While::evalLoopStartCondition() {
568			if (!m_condition) return false;
569			return m_condition->evalInt();
570			}
571
572			void Neg::dump(int level) {
573			printIndents(level);
574			printf("Negative Expr\n");
575			}
576
577			String ConcatString::evalStr() {
578			return lhs->evalCastToStr() + rhs->evalCastToStr();
579			}
580
581			void ConcatString::dump(int level) {
582			printIndents(level);
583			printf("ConcatString(\n");
584			lhs->dump(level+1);
585			printIndents(level);
586			printf(",\n");
587			rhs->dump(level+1);
588			printIndents(level);
589			printf(")");
590			}
591
592			bool ConcatString::isConstExpr() const {
593			return lhs->isConstExpr() && rhs->isConstExpr();
594			}
595
596			int Relation::evalInt() {
597			switch (type) {
598			case LESS_THAN:
599			return lhs->evalInt() < rhs->evalInt();
600			case GREATER_THAN:
601			return lhs->evalInt() > rhs->evalInt();
602			case LESS_OR_EQUAL:
603			return lhs->evalInt() <= rhs->evalInt();
604			case GREATER_OR_EQUAL:
605			return lhs->evalInt() >= rhs->evalInt();
606			case EQUAL:
607			if (lhs->exprType() == STRING_EXPR \|\| rhs->exprType() == STRING_EXPR)
608			return lhs->evalCastToStr() == rhs->evalCastToStr();
609			else
610			return lhs->evalInt() == rhs->evalInt();
611			case NOT_EQUAL:
612			if (lhs->exprType() == STRING_EXPR \|\| rhs->exprType() == STRING_EXPR)
613			return lhs->evalCastToStr() != rhs->evalCastToStr();
614			else
615			return lhs->evalInt() != rhs->evalInt();
616			}
617			return 0;
618			}
619
620			void Relation::dump(int level) {
621			printIndents(level);
622			printf("Relation(\n");
623			lhs->dump(level+1);
624			printIndents(level);
625			switch (type) {
626			case LESS_THAN:
627			printf("LESS_THAN\n");
628			break;
629			case GREATER_THAN:
630			printf("GREATER_THAN\n");
631			break;
632			case LESS_OR_EQUAL:
633			printf("LESS_OR_EQUAL\n");
634			break;
635			case GREATER_OR_EQUAL:
636			printf("GREATER_OR_EQUAL\n");
637			break;
638			case EQUAL:
639			printf("EQUAL\n");
640			break;
641			case NOT_EQUAL:
642			printf("NOT_EQUAL\n");
643			break;
644			}
645			rhs->dump(level+1);
646			printIndents(level);
647			printf(")\n");
648			}
649
650			bool Relation::isConstExpr() const {
651			return lhs->isConstExpr() && rhs->isConstExpr();
652			}
653
654			int Or::evalInt() {
655			IntExpr* pLHS = dynamic_cast<IntExpr>(&lhs);
656			IntExpr* pRHS = dynamic_cast<IntExpr>(&rhs);;
657			return pLHS->evalInt() \|\| pRHS->evalInt();
658			}
659
660			void Or::dump(int level) {
661			printIndents(level);
662			printf("Or(\n");
663			lhs->dump(level+1);
664			printIndents(level);
665			printf(",\n");
666			rhs->dump(level+1);
667			printIndents(level);
668			printf(")\n");
669			}
670
671			int And::evalInt() {
672			IntExpr* pLHS = dynamic_cast<IntExpr>(&lhs);
673			IntExpr* pRHS = dynamic_cast<IntExpr>(&rhs);;
674			return pLHS->evalInt() && pRHS->evalInt();
675			}
676
677			void And::dump(int level) {
678			printIndents(level);
679			printf("And(\n");
680			lhs->dump(level+1);
681			printIndents(level);
682			printf(",\n");
683			rhs->dump(level+1);
684			printIndents(level);
685			printf(")\n");
686			}
687
688			void Not::dump(int level) {
689			printIndents(level);
690			printf("Not(\n");
691			expr->dump(level+1);
692			printIndents(level);
693			printf(")\n");
694			}
695
696			VariableRef ParserContext::variableByName(const String& name) {
697			if (!vartable.count(name)) {
698			return VariableRef();
699			}
700			return vartable.find(name)->second;
701			}
702
703			VariableRef ParserContext::globalVar(const String& name) {
704			if (!vartable.count(name)) {
705			//printf("No global var '%s'\n", name.c_str());
706			//for (std::map<String,VariableRef>::const_iterator it = vartable.begin(); it != vartable.end(); ++it)
707			// printf("-> var '%s'\n", it->first.c_str());
708			return VariableRef();
709			}
710			return vartable.find(name)->second;
711			}
712
713			IntVariableRef ParserContext::globalIntVar(const String& name) {
714			return globalVar(name);
715			}
716
717			StringVariableRef ParserContext::globalStrVar(const String& name) {
718			return globalVar(name);
719			}
720
721			void ParserContext::addErr(int line, const char* txt) {
722			ParserIssue e;
723			e.type = PARSER_ERROR;
724			e.txt = txt;
725			e.line = line;
726			errors.push_back(e);
727			issues.push_back(e);
728			}
729
730			void ParserContext::addWrn(int line, const char* txt) {
731			ParserIssue w;
732			w.type = PARSER_WARNING;
733			w.txt = txt;
734			w.line = line;
735			warnings.push_back(w);
736			issues.push_back(w);
737			}
738
739			bool ParserContext::setPreprocessorCondition(const char* name) {
740			if (builtinPreprocessorConditions.count(name)) return false;
741			if (userPreprocessorConditions.count(name)) return false;
742			userPreprocessorConditions.insert(name);
743			return true;
744			}
745
746			bool ParserContext::resetPreprocessorCondition(const char* name) {
747			if (builtinPreprocessorConditions.count(name)) return false;
748			if (!userPreprocessorConditions.count(name)) return false;
749			userPreprocessorConditions.erase(name);
750			return true;
751			}
752
753			bool ParserContext::isPreprocessorConditionSet(const char* name) {
754			if (builtinPreprocessorConditions.count(name)) return true;
755			return userPreprocessorConditions.count(name);
756			}
757
758			} // namespace LinuxSampler