translate, interpreter and statements updated for csparql

Author: emrekenar

src/main/kotlin/no/uio/microobject/ast/Translate.kt

@@ -22,6 +22,7 @@ class Translate : WhileBaseVisitor<ProgramElement>() {
     private val classifiesTable: MutableMap<String, Pair<String, String>> = mutableMapOf()
     private val checkClassifiesTable: MutableMap<String, MutableMap<String, Pair<String, String>>> = mutableMapOf()
     private val contextTable : MutableMap<String, String> = mutableMapOf()
+    private val streamersTable : MutableMap<String, MutableMap<String, MutableSet<Expression>>> = mutableMapOf()
 
     private fun translateModels(ctx : Models_blockContext) : Pair<List<Pair<Expression, String>>, String>{
         if(ctx is Simple_models_blockContext)
@@ -75,6 +76,11 @@ class Translate : WhileBaseVisitor<ProgramElement>() {
                     addClassifyQuery(cl.className.text, cl.classifies_block(), null)
                 }
             }
+
+            // create streamer configuration
+            if (cl.streamer != null) {
+                streamersTable[cl.className.text] = mutableMapOf()
+            }
             val inFields = if(cl.external != null) {
                 var res = listOf<FieldInfo>()
                 if(cl.external.fieldDecl() != null) {
@@ -141,6 +147,14 @@ class Translate : WhileBaseVisitor<ProgramElement>() {
                     val params = if (nm.paramList() != null) paramListTranslate(nm.paramList()) else listOf()
                     res[nm.NAME().text] = MethodInfo(SkipStmt(ctx!!.start.line), params, nm.builtinrule != null, nm.domainrule != null, cl.className.text, metType)
                 }
+                if (nm.emits_block() != null) {
+                    if (!streamersTable.containsKey(cl.className.text))
+                        throw Exception("Class with methods containing emits clause must be a streamer: ${nm.NAME().text}")
+
+                    streamersTable[cl.className.text]!![nm.NAME().text] = mutableSetOf()
+                    for(i in 0 until nm.emits_block().expression().size)
+                        streamersTable[cl.className.text]!![nm.NAME().text]!! += visit(nm.emits_block().expression(i)) as Expression
+                }
             }
             table[cl.className.text] = Pair(fields, res)
         }
@@ -179,7 +193,7 @@ class Translate : WhileBaseVisitor<ProgramElement>() {
 
         return Pair(
                      StackEntry(visit(ctx.statement()) as Statement, mutableMapOf(), Names.getObjName("_Entry_"), Names.getStackId()),
-                     StaticTable(fieldTable, methodTable, hierarchy, modelsTable, hidden, owldescr, checkClassifiesTable, contextTable)
+                     StaticTable(fieldTable, methodTable, hierarchy, modelsTable, hidden, owldescr, checkClassifiesTable, contextTable, streamersTable)
                    )
     }
 
@@ -402,6 +416,35 @@ class Translate : WhileBaseVisitor<ProgramElement>() {
         return SimulationStmt(target, path,  res, ctx!!.start.line, declares)
     }
 
+    override fun visitMonitor_statement(ctx: Monitor_statementContext?): ProgramElement {
+        val target = visit(ctx!!.target) as Location
+        if(ctx.declType != null) {
+            val decl = getClassDecl(ctx)
+            val className = if(decl == null) ERRORTYPE.name else decl!!.className.text
+            val targetType = TypeChecker.translateType(ctx.declType, className, mutableMapOf())
+            target.setType(targetType)
+        }
+
+        val query = visit(ctx!!.registeredQuery) as Expression
+        val ll = emptyList<Expression>().toMutableList()
+        for(i in 2 until ctx!!.expression().size)
+            ll += visit(ctx.expression(i)) as Expression
+
+        return MonitorStmt(target, query, ll, ctx!!.start.line, target.getType())
+    }
+
+    override fun visitWindow_statement(ctx: Window_statementContext?): ProgramElement {
+        val target = visit(ctx!!.target) as Location
+        if(ctx.declType != null) {
+            val decl = getClassDecl(ctx)
+            val className = if(decl == null) ERRORTYPE.name else decl!!.className.text
+            val targetType = TypeChecker.translateType(ctx.declType, className, mutableMapOf())
+            target.setType(targetType)
+        }
+        val monitor = visit(ctx!!.monitor) as Expression
+        return WindowStmt(target, monitor, ctx!!.start.line, declares=target.getType())
+    }
+
     override fun visitTick_statement(ctx: Tick_statementContext?): ProgramElement {
         return TickStmt(visit(ctx!!.fmu) as Expression, visit(ctx!!.time) as Expression )
     }
@@ -418,7 +461,8 @@ class Translate : WhileBaseVisitor<ProgramElement>() {
         val def = getClassDecl(ctx as RuleContext)
         val declares = if(ctx!!.declType == null) null else
             TypeChecker.translateType(ctx.declType, if(def != null) def!!.className.text else ERRORTYPE.name, mutableMapOf())
-        return AssignStmt(visit(ctx!!.expression(0)) as Location, visit(ctx.expression(1)) as Expression, ctx!!.start.line, declares)
+        val isClock = if(ctx.clock == null) false else true
+        return AssignStmt(visit(ctx!!.expression(0)) as Location, visit(ctx.expression(1)) as Expression, isClock, ctx!!.start.line, declares)
     }
 
     override fun visitSkip_statment(ctx: Skip_statmentContext?): ProgramElement {

src/main/kotlin/no/uio/microobject/ast/stmt/AssignStmt.kt

@@ -10,9 +10,10 @@ import no.uio.microobject.runtime.Memory
 import no.uio.microobject.runtime.StackEntry
 import no.uio.microobject.type.BaseType
 import no.uio.microobject.type.Type
+import no.uio.microobject.type.INTTYPE
 
 // Assignment, where value cannot refer to calls or object creations.
-data class AssignStmt(val target : Location, val value : Expression, val pos : Int = -1, val declares: Type?) :
+data class AssignStmt(val target : Location, val value : Expression, val isClock: Boolean = false, val pos : Int = -1, val declares: Type?) :
     Statement {
     override fun toString(): String = "$target := $value"
     override fun getRDF(): String {
@@ -28,7 +29,14 @@ data class AssignStmt(val target : Location, val value : Expression, val pos : I
     override fun eval(heapObj: Memory, stackFrame : StackEntry, interpreter: Interpreter) : EvalResult {
         val res = interpreter.eval(value, stackFrame)
         when (target) {
-            is LocalVar -> stackFrame.store[target.name] = res
+            is LocalVar -> {
+                if (isClock && interpreter.streamManager.clockVar == null) {
+                    interpreter.streamManager.clockVar = target.name
+                }
+                if (interpreter.streamManager.clockVar != null && target.name.equals(interpreter.streamManager.clockVar) 
+                    && res.tag == INTTYPE) interpreter.streamManager.clockTimestampSec = res.literal
+                stackFrame.store[target.name] = res
+            }
             is OwnVar -> {
                 val got = interpreter.staticInfo.fieldTable[(stackFrame.obj.tag as BaseType).name] ?: throw Exception("Cannot find class ${stackFrame.obj.tag.name}")
                 if (!got.map {it.name} .contains(target.name))

src/main/kotlin/no/uio/microobject/ast/stmt/CallStmt.kt

@@ -39,8 +39,14 @@ data class CallStmt(val target : Location, val callee : Location, val method : S
         for (i in m.params.indices) {
             newMemory[m.params[i]] = interpreter.eval(params[i], stackFrame)
         }
+
+        var emitFromMethod: String? = null
+        if (interpreter.staticInfo.streamersTable.containsKey(newObj.tag.name) &&
+            interpreter.staticInfo.streamersTable[newObj.tag.name]!!.containsKey(method))
+            emitFromMethod = method
+
         return EvalResult(
-            StackEntry(StoreReturnStmt(target), stackFrame.store, stackFrame.obj, stackFrame.id),
+            StackEntry(StoreReturnStmt(target, emitFromMethod=emitFromMethod), stackFrame.store, stackFrame.obj, stackFrame.id),
             listOf(StackEntry(m.stmt, newMemory, newObj, Names.getStackId()))
         )
     }

src/main/kotlin/no/uio/microobject/ast/stmt/ConstructStmt.kt

@@ -109,6 +109,9 @@ data class ConstructStmt(val target : Location, val query: Expression, val param
                 newListMemory["next"] = list
                 interpreter.heap[newListName] = newListMemory
                 list = newListName
+                if (interpreter.staticInfo.streamersTable.containsKey(className)) {
+                    interpreter.streamManager.registerStream(className, newObjName)
+                }
             }
         }
         return replaceStmt(AssignStmt(target, list, declares = declares), stackFrame)

src/main/kotlin/no/uio/microobject/ast/stmt/CreateStmt.kt

@@ -50,6 +50,9 @@ data class CreateStmt(val target : Location, val className: String, val params :
         interpreter.heap[name] = newMemory
         val localFrame = StackEntry(SkipStmt(), mutableMapOf(Pair("this", name)),name,0)
         n.filter { it.internalInit != null }.forEach { newMemory[it.name] = interpreter.eval(it.internalInit!!, localFrame) }
+        if (interpreter.staticInfo.streamersTable.containsKey(className)) {
+            interpreter.streamManager.registerStream(className, name)
+        }
         return replaceStmt(AssignStmt(target, name, declares = declares), stackFrame)
     }
 }

src/main/kotlin/no/uio/microobject/ast/stmt/ReturnStmt.kt

@@ -5,6 +5,7 @@ import no.uio.microobject.runtime.EvalResult
 import no.uio.microobject.runtime.Interpreter
 import no.uio.microobject.runtime.Memory
 import no.uio.microobject.runtime.StackEntry
+import no.uio.microobject.type.BaseType
 
 // Return statement
 data class ReturnStmt(var value : Expression, val pos : Int = -1) : Statement {
@@ -22,6 +23,7 @@ data class ReturnStmt(var value : Expression, val pos : Int = -1) : Statement {
         val over = interpreter.stack.pop()
         if (over.active is StoreReturnStmt) {
             val res = interpreter.eval(value, stackFrame)
+            checkTriggerStream(over.active, stackFrame, interpreter)
             return EvalResult(
                 StackEntry(
                     AssignStmt(over.active.target, res, declares = null),
@@ -35,8 +37,17 @@ data class ReturnStmt(var value : Expression, val pos : Int = -1) : Statement {
             val active = over.active.first
             val next = over.active.second
             val res = interpreter.eval(value, stackFrame)
+            checkTriggerStream(over.active.first, stackFrame, interpreter)
             return replaceStmt(appendStmt(AssignStmt(active.target, res, declares = null), next), over)
         }
         throw Exception("Malformed heap")
     }
+
+    // trigger stream at the end of emission method, right before returning the result
+    private fun checkTriggerStream(storeReturnStmt: StoreReturnStmt, stackFrame: StackEntry, interpreter: Interpreter) {
+        if (storeReturnStmt.emitFromMethod != null) {
+            val className = (stackFrame.obj.tag as BaseType).name
+            interpreter.streamManager.triggerStream(className, stackFrame.obj, storeReturnStmt.emitFromMethod, stackFrame)
+        }
+    }
 }

src/main/kotlin/no/uio/microobject/ast/stmt/StoreReturnStmt.kt

@@ -8,7 +8,7 @@ import no.uio.microobject.runtime.Memory
 import no.uio.microobject.runtime.StackEntry
 
 // This is a runtime-syntax only statement which models that we will write the return value of the next method in the stack into target
-data class StoreReturnStmt(val target : Location, val pos : Int = -1) : Statement {
+data class StoreReturnStmt(val target : Location, val pos : Int = -1, val emitFromMethod: String? = null) : Statement {
     override fun toString(): String = "$target <- stack"
     override fun getRDF(): String {
         return """

src/main/kotlin/no/uio/microobject/runtime/Interpreter.kt

@@ -14,7 +14,9 @@ import kotlinx.coroutines.runBlocking
 import no.uio.microobject.ast.*
 import no.uio.microobject.ast.expr.LiteralExpr
 import no.uio.microobject.ast.stmt.ReturnStmt
+import no.uio.microobject.ast.stmt.MonitorObject
 import no.uio.microobject.data.TripleManager
+import no.uio.microobject.data.StreamManager
 import no.uio.microobject.main.Settings
 import no.uio.microobject.type.*
 import org.apache.jena.query.QueryExecution
@@ -68,6 +70,7 @@ class Interpreter(
 
     // TripleManager used to provide virtual triples etc.
     val tripleManager : TripleManager = TripleManager(settings, staticInfo, this)
+    val streamManager : StreamManager = StreamManager(settings, staticInfo, this)
 
     /**
      * Evaluates a call on a method of a class

src/main/kotlin/no/uio/microobject/runtime/State.kt

@@ -3,6 +3,7 @@ package no.uio.microobject.runtime
 import no.uio.microobject.ast.Expression
 import no.uio.microobject.ast.expr.LiteralExpr
 import no.uio.microobject.ast.Statement
+import no.uio.microobject.ast.stmt.MonitorObject
 import no.uio.microobject.type.Type
 import org.apache.jena.query.ResultSet
 
@@ -29,8 +30,8 @@ data class StaticTable(
     val hiddenSet: Set<String>,//This set of classes is skipped by the lifting
     val owldescr: MutableMap<String, String>, // This maps class names to the default models block
     val checkClassifiesTable: MutableMap<String, MutableMap<String, Pair<String, String>>> = mutableMapOf(), // Queries for classification
-    val contextTable: MutableMap<String, String>
-
+    val contextTable: MutableMap<String, String>,
+    val streamersTable: MutableMap<String, MutableMap<String, MutableSet<Expression>>>
 ) {
     override fun toString(): String =
 """