stevedlawrence commented on a change in pull request #225: Implement
daf:lookAhead
URL: https://github.com/apache/incubator-daffodil/pull/225#discussion_r290266903
##########
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:
Any particular reason for the explicit Long.box() calls? I don't think we do
that anywhere else. Also, should it be a JLong instead? I *think* we tend to
use java types in DPath.
----------------------------------------------------------------
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:
[email protected]
With regards,
Apache Git Services
