--- linuxsampler/trunk/src/engines/common/InstrumentScriptVMFunctions.cpp	2014/06/12 18:25:11	2629
+++ linuxsampler/trunk/src/engines/common/InstrumentScriptVMFunctions.cpp	2014/06/13 15:01:06	2630
@@ -103,17 +103,28 @@
     {
     }
 
-    VMFnResult* InstrumentScriptVMFunction_ignore_event::exec(VMFnArgs* args) {
-        int id = args->arg(0)->asInt()->evalInt();
-        if (id < 0) {
-            wrnMsg("ignore_event(): argument may not be a negative event ID");
-            return successResult();
-        }
+    bool InstrumentScriptVMFunction_ignore_event::acceptsArgType(int iArg, ExprType_t type) const {
+        return type == INT_EXPR || type == INT_ARR_EXPR;
+    }
 
+    VMFnResult* InstrumentScriptVMFunction_ignore_event::exec(VMFnArgs* args) {
         AbstractEngineChannel* pEngineChannel =
-            static_cast<AbstractEngineChannel*>(m_vm->m_event->cause.pEngineChannel);
+                static_cast<AbstractEngineChannel*>(m_vm->m_event->cause.pEngineChannel);
 
-        pEngineChannel->IgnoreEvent(id);
+        if (args->arg(0)->exprType() == INT_EXPR) {
+            int id = args->arg(0)->asInt()->evalInt();
+            if (id < 0) {
+                wrnMsg("ignore_event(): argument may not be a negative event ID");
+                return successResult();
+            }
+            pEngineChannel->IgnoreEvent(id);
+        } else if (args->arg(0)->exprType() == INT_ARR_EXPR) {
+            VMIntArrayExpr* ids = args->arg(0)->asIntArray();
+            for (int i = 0; i < ids->arraySize(); ++i) {
+                int id = ids->evalIntElement(i);
+                pEngineChannel->IgnoreEvent(id);
+            }
+        }
 
         return successResult();
     }
@@ -143,34 +154,140 @@
     {
     }
 
+    bool InstrumentScriptVMFunction_note_off::acceptsArgType(int iArg, ExprType_t type) const {
+        return type == INT_EXPR || type == INT_ARR_EXPR;
+    }
+
     VMFnResult* InstrumentScriptVMFunction_note_off::exec(VMFnArgs* args) {
-        int id = args->arg(0)->asInt()->evalInt();
+        AbstractEngineChannel* pEngineChannel =
+            static_cast<AbstractEngineChannel*>(m_vm->m_event->cause.pEngineChannel);
+
         int velocity = (args->argsCount() >= 2) ? args->arg(1)->asInt()->evalInt() : 127;
+        if (velocity < 0 || velocity > 127) {
+            errMsg("note_off(): argument 2 is an invalid velocity value");
+            return errorResult();
+        }
 
-        if (id < 0) {
-            wrnMsg("note_off(): argument 1 may not be a negative event ID");
-            return successResult();
+        if (args->arg(0)->exprType() == INT_EXPR) {
+            int id = args->arg(0)->asInt()->evalInt();   
+            if (id < 0) {
+                wrnMsg("note_off(): argument 1 may not be a negative event ID");
+                return successResult();
+            }
+
+            RTList<Event>::Iterator itEvent = pEngineChannel->pEngine->EventByID(id);
+            if (!itEvent) return successResult();
+
+            Event e = *itEvent;
+            e.Type = Event::type_note_off;
+            e.Param.Note.Velocity = velocity;
+            memset(&e.Format, 0, sizeof(e.Format)); // init format speific stuff with zero
+
+            int releaseEventID = pEngineChannel->ScheduleEvent(&e, 0);
+        } else if (args->arg(0)->exprType() == INT_ARR_EXPR) {
+            VMIntArrayExpr* ids = args->arg(0)->asIntArray();
+            for (int i = 0; i < ids->arraySize(); ++i) {
+                int id = ids->evalIntElement(i);
+
+                RTList<Event>::Iterator itEvent = pEngineChannel->pEngine->EventByID(id);
+                if (!itEvent) continue;
+
+                Event e = *itEvent;
+                e.Type = Event::type_note_off;
+                e.Param.Note.Velocity = velocity;
+                memset(&e.Format, 0, sizeof(e.Format)); // init format speific stuff with zero
+
+                int releaseEventID = pEngineChannel->ScheduleEvent(&e, 0);
+            }
         }
 
-        if (velocity < 0 || velocity > 127) {
-            errMsg("note_off(): argument 2 is an invalid velocity value");
+        return successResult();
+    }
+
+    InstrumentScriptVMFunction_set_event_mark::InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent)
+        : m_vm(parent)
+    {
+    }
+
+    VMFnResult* InstrumentScriptVMFunction_set_event_mark::exec(VMFnArgs* args) {
+        int eventID = args->arg(0)->asInt()->evalInt();
+        int groupID = args->arg(1)->asInt()->evalInt();
+
+        if (groupID < 0 || groupID >= INSTR_SCRIPT_EVENT_GROUPS) {
+            errMsg("set_event_mark(): argument 2 is an invalid group id");
             return errorResult();
         }
 
         AbstractEngineChannel* pEngineChannel =
             static_cast<AbstractEngineChannel*>(m_vm->m_event->cause.pEngineChannel);
 
-        RTList<Event>::Iterator itEvent = pEngineChannel->pEngine->EventByID(id);
+        RTList<Event>::Iterator itEvent = pEngineChannel->pEngine->EventByID(eventID);
         if (!itEvent) return successResult();
 
-        Event e = *itEvent;
-        e.Type = Event::type_note_off;
-        e.Param.Note.Velocity = velocity;
-        memset(&e.Format, 0, sizeof(e.Format)); // init format speific stuff with zero
+        pEngineChannel->pScript->eventGroups[groupID].insert(eventID);
+
+        return successResult();
+    }
+
+    InstrumentScriptVMFunction_delete_event_mark::InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent)
+        : m_vm(parent)
+    {
+    }
 
-        int releaseEventID = pEngineChannel->ScheduleEvent(&e, 0);
+    VMFnResult* InstrumentScriptVMFunction_delete_event_mark::exec(VMFnArgs* args) {
+        int eventID = args->arg(0)->asInt()->evalInt();
+        int groupID = args->arg(1)->asInt()->evalInt();
+
+        if (groupID < 0 || groupID >= INSTR_SCRIPT_EVENT_GROUPS) {
+            errMsg("delete_event_mark(): argument 2 is an invalid group id");
+            return errorResult();
+        }
+
+        AbstractEngineChannel* pEngineChannel =
+            static_cast<AbstractEngineChannel*>(m_vm->m_event->cause.pEngineChannel);
+
+        pEngineChannel->pScript->eventGroups[groupID].erase(eventID);
 
         return successResult();
     }
 
+    InstrumentScriptVMFunction_by_marks::InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent)
+        : m_vm(parent)
+    {
+    }
+
+    int InstrumentScriptVMFunction_by_marks::Result::arraySize() const {
+        return eventGroup->size();
+    }
+
+    int InstrumentScriptVMFunction_by_marks::Result::evalIntElement(uint i) {
+        return (*eventGroup)[i];
+    }
+
+    VMFnResult* InstrumentScriptVMFunction_by_marks::errorResult() {
+        m_result.eventGroup = NULL;
+        m_result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
+        return &m_result;
+    }
+
+    VMFnResult* InstrumentScriptVMFunction_by_marks::successResult(EventGroup* eventGroup) {
+        m_result.eventGroup = eventGroup;
+        m_result.flags = STMT_SUCCESS;
+        return &m_result;
+    }
+
+    VMFnResult* InstrumentScriptVMFunction_by_marks::exec(VMFnArgs* args) {
+        int groupID = args->arg(0)->asInt()->evalInt();
+
+        if (groupID < 0 || groupID >= INSTR_SCRIPT_EVENT_GROUPS) {
+            errMsg("by_marks(): argument is an invalid group id");
+            return errorResult();
+        }
+
+        AbstractEngineChannel* pEngineChannel =
+            static_cast<AbstractEngineChannel*>(m_vm->m_event->cause.pEngineChannel);
+
+        return successResult( &pEngineChannel->pScript->eventGroups[groupID] );
+    }
+
 } // namespace LinuxSampler