[GitHub] [incubator-daffodil] mbeckerle commented on a change in pull request #225: Implement daf:lookAhead

[GitBox <gi...@apache.org>]

mbeckerle commented on a change in pull request #225: Implement daf:lookAhead
URL: https://github.com/apache/incubator-daffodil/pull/225#discussion_r290439158
 
 

 ##########
 File path: daffodil-runtime1/src/main/scala/org/apache/daffodil/dpath/DAFFunctions.scala
 ##########
 @@ -72,3 +78,63 @@ case object DAFError extends RecipeOp {
     }
   }
 }
+
+case class DAFLookAhead(recipes: List[CompiledDPath])
+  extends FNTwoArgs(recipes) {
+
+  def computeValue(arg1: AnyRef, arg2: AnyRef, dstate: DState): AnyRef = {
+    val offset = arg1.asInstanceOf[JLong]
+    val lBitSize = arg2.asInstanceOf[JLong]
+
+    /*
+     * Since daf:lookAhead is defined to take unsigned arguements, the DPath interperater
+     * will error out on the cast if a negative arguement is supplied, so we do not need to SDE here.
+     */
+
+    Assert.invariant(offset >= 0)
+    Assert.invariant(lBitSize >= 0)
+
+    val totalLookahead = offset + lBitSize
+    if (totalLookahead > 512) {
+      dstate.SDE("Look-ahead distance of %s bits exceeds implementation defined limit of 512 bits", totalLookahead)
+    }
+    //Safe since we guard on totalLookahead
+    val bitSize = lBitSize.toInt
+
+    if (!dstate.parseOrUnparseState.isDefined) {
+      Assert.invariant(dstate.isCompile)
+      /*
+        * This is an expected code path.
+        * Throwing an exception is how we indicated that this expression does
+        * cannot be reduced to a constant at compile time.
+        */
+      throw new IllegalStateException("No input stream at compile time")
+    }
+    if (dstate.parseOrUnparseState.get.isInstanceOf[PState]) {
+      val pstate = dstate.parseOrUnparseState.get.asInstanceOf[PState]
+      val dis = pstate.dataInputStream
+      if (!dis.isDefinedForLength(totalLookahead)) {
+        val maybeSFL =
+          if (dstate.runtimeData.isDefined) One(dstate.runtimeData.get.schemaFileLocation)
+          else Nope
+        throw new ParseError(maybeSFL, dstate.contextLocation, Nope,
+          One("Insufficient bits available to satisfy daf:lookAhead(%s,%s)."),
+          offset, bitSize, totalLookahead)
+      }
+      val mark = dis.markPos
+      dis.skip(offset, pstate)
+      val ans: AnyRef = if (bitSize > 63) {
+        dis.getUnsignedBigInt(bitSize, pstate)
+      } else if (bitSize == 0) {
+        Long.box(0)
+      } else {
+        Long.box(dis.getUnsignedLong(bitSize, pstate).longValue)
+      }
 
 Review comment:
   I don't know of a way in Scala 2.x to create a untagged union type. You can create type that works kind of like Maybe types that will, at runtime, restrict the type of the argument to one of several kiinds, and you can have overloaded constructors only for those types, so as to get a compile time error. 

----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
 
For queries about this service, please contact Infrastructure at:
users@infra.apache.org


With regards,
Apache Git Services