You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@daffodil.apache.org by GitBox <gi...@apache.org> on 2018/12/12 15:44:28 UTC
[GitHub] mbeckerle closed pull request #150: Removed use of ThreadLocal for
DFA Register Pool.
mbeckerle closed pull request #150: Removed use of ThreadLocal for DFA Register Pool.
URL: https://github.com/apache/incubator-daffodil/pull/150
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/ProcessorStateBases.scala b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/ProcessorStateBases.scala
index 114b82149..77bf24de4 100644
--- a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/ProcessorStateBases.scala
+++ b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/ProcessorStateBases.scala
@@ -59,6 +59,10 @@ import org.apache.daffodil.schema.annotation.props.gen.ByteOrder
import org.apache.daffodil.processors.charset.BitsCharsetDecoder
import org.apache.daffodil.processors.charset.BitsCharsetEncoder
import org.apache.daffodil.processors.unparsers.UState
+import org.apache.daffodil.processors.dfa.Registers
+import org.apache.daffodil.processors.dfa.RegistersPool
+import org.apache.daffodil.processors.dfa.RegistersPool
+import org.apache.daffodil.processors.dfa.RegistersPool
/**
* Trait mixed into the PState.Mark object class and the ParseOrUnparseState
@@ -75,8 +79,7 @@ trait StateForDebugger {
def discriminator: Boolean = false
}
-case class TupleForDebugger(
- val bytePos: Long,
+case class TupleForDebugger(val bytePos: Long,
val childPos: Long,
val groupPos: Long,
val currentLocation: DataLocation,
@@ -119,8 +122,7 @@ trait SetProcessorMixin {
* which should be isolated to the alternative parser, and repParsers, i.e.,
* places where points-of-uncertainty are handled.
*/
-abstract class ParseOrUnparseState protected (
- protected var variableBox: VariableBox,
+abstract class ParseOrUnparseState protected (protected var variableBox: VariableBox,
var diagnostics: List[Diagnostic],
var dataProc: Maybe[DataProcessor],
val tunable: DaffodilTunables) extends DFDL.State
@@ -493,6 +495,20 @@ abstract class ParseOrUnparseState protected (
}
}
+ /**
+ * Pool of registers for use by low-level text DFA code.
+ */
+ object dfaRegistersPool {
+ private val pool = new RegistersPool()
+
+ def getFromPool(requestorID: String) =
+ pool.getFromPool(requestorID)
+
+ def returnToPool(r: Registers) = pool.returnToPool(r)
+
+ def finalCheck() = pool.finalCheck
+ }
+
}
/**
diff --git a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/Registers.scala b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/Registers.scala
index 3b7ba7019..3abd4c6bf 100644
--- a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/Registers.scala
+++ b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/Registers.scala
@@ -24,18 +24,7 @@ import org.apache.daffodil.util.Pool
import org.apache.daffodil.util.Poolable
import org.apache.daffodil.io.FormatInfo
-private[dfa] object TLRegistersPool extends ThreadLocal[RegistersPool] {
- override def initialValue = new RegistersPool()
-
- def pool() = this.get
-
- def getFromPool(requestorID: String) =
- pool.getFromPool(requestorID)
-
- def returnToPool(r: Registers) = pool.returnToPool(r)
-}
-
-private[dfa] class RegistersPool() extends Pool[Registers] {
+class RegistersPool() extends Pool[Registers] {
override def allocate = new Registers()
}
diff --git a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextDelimitedParser.scala b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextDelimitedParser.scala
index 67b484b36..dff51af21 100644
--- a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextDelimitedParser.scala
+++ b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextDelimitedParser.scala
@@ -29,9 +29,9 @@ import org.apache.daffodil.equality._
import org.apache.daffodil.util.MaybeChar
import org.apache.daffodil.processors.DelimiterIterator
import org.apache.daffodil.io.FormatInfo
+import org.apache.daffodil.processors.parsers.PState
-abstract class TextDelimitedParserBase(
- override val justificationTrim: TextJustificationType.Type,
+abstract class TextDelimitedParserBase(override val justificationTrim: TextJustificationType.Type,
override val parsingPadChar: MaybeChar,
override val context: TermRuntimeData)
extends DFAParser with PaddingRuntimeMixin {
@@ -39,14 +39,14 @@ abstract class TextDelimitedParserBase(
private lazy val padCharInfo = if (parsingPadChar.isDefined) parsingPadChar.toString else "NONE"
lazy val info: String = "justification='" + justificationTrim + "', padChar='" + padCharInfo + "'"
- final def parse(finfo: FormatInfo, input: DataInputStream, field: DFAField, delimIter: DelimiterIterator, isDelimRequired: Boolean): Maybe[ParseResult] = {
+ final def parse(state: PState, input: DataInputStream, field: DFAField, delimIter: DelimiterIterator, isDelimRequired: Boolean): Maybe[ParseResult] = {
Assert.invariant(field != null)
val lmt = new LongestMatchTracker()
- val fieldReg: Registers = TLRegistersPool.getFromPool("TextDelimitedParserBase1")
+ val fieldReg: Registers = state.dfaRegistersPool.getFromPool("TextDelimitedParserBase1")
- fieldReg.reset(finfo, input, delimIter) // Initialization
+ fieldReg.reset(state, input, delimIter) // Initialization
var stillSearching: Boolean = true
var beforeDelimiter: DataInputStream.MarkPos = DataInputStream.MarkPos.NoMarkPos
@@ -66,13 +66,13 @@ abstract class TextDelimitedParserBase(
val d = delimIter.next()
input.resetPos(beforeDelimiter)
beforeDelimiter = input.markPos
- val delimReg: Registers = TLRegistersPool.getFromPool("TextDelimitedParserBase2")
- delimReg.reset(finfo, input, delimIter)
+ val delimReg: Registers = state.dfaRegistersPool.getFromPool("TextDelimitedParserBase2")
+ delimReg.reset(state, input, delimIter)
d.run(delimReg)
if (delimReg.status == StateKind.Succeeded) {
lmt.successfulMatch(delimReg.matchStartPos, delimReg.delimString, d, delimIter.currentIndex)
}
- TLRegistersPool.returnToPool(delimReg)
+ state.dfaRegistersPool.returnToPool(delimReg)
}
if (!lmt.longestMatches.isEmpty) { stillSearching = false }
else {
@@ -137,8 +137,8 @@ abstract class TextDelimitedParserBase(
}
}
- TLRegistersPool.returnToPool(fieldReg)
- TLRegistersPool.pool.finalCheck
+ state.dfaRegistersPool.returnToPool(fieldReg)
+ state.dfaRegistersPool.finalCheck
result
}
@@ -149,8 +149,7 @@ abstract class TextDelimitedParserBase(
* Assumes that the delims DFAs were constructed with the Esc
* and EscEsc in mind.
*/
-class TextDelimitedParser(
- justArg: TextJustificationType.Type,
+class TextDelimitedParser(justArg: TextJustificationType.Type,
padCharArg: MaybeChar,
context: TermRuntimeData)
extends TextDelimitedParserBase(justArg, padCharArg, context) {
@@ -163,8 +162,7 @@ class TextDelimitedParser(
* Assumes that endBlock DFA was constructed with the
* EscEsc in mind.
*/
-class TextDelimitedParserWithEscapeBlock(
- justArg: TextJustificationType.Type,
+class TextDelimitedParserWithEscapeBlock(justArg: TextJustificationType.Type,
padCharArg: MaybeChar,
context: TermRuntimeData)
extends TextDelimitedParserBase(justArg, padCharArg, context) {
@@ -185,37 +183,37 @@ class TextDelimitedParserWithEscapeBlock(
}
}
- protected def removeLeftPadding(finfo: FormatInfo, input: DataInputStream, delimIter: DelimiterIterator): Unit = {
+ protected def removeLeftPadding(state: PState, input: DataInputStream, delimIter: DelimiterIterator): Unit = {
justificationTrim match {
case TextJustificationType.Center | TextJustificationType.Right if parsingPadChar.isDefined => {
- val leftPaddingRegister = TLRegistersPool.getFromPool("removeLeftPadding")
- leftPaddingRegister.reset(finfo, input, delimIter)
+ val leftPaddingRegister = state.dfaRegistersPool.getFromPool("removeLeftPadding")
+ leftPaddingRegister.reset(state, input, delimIter)
leftPadding.run(leftPaddingRegister)
- TLRegistersPool.returnToPool(leftPaddingRegister)
+ state.dfaRegistersPool.returnToPool(leftPaddingRegister)
}
case _ => // No left padding
}
}
- protected def removeRightPadding(finfo: FormatInfo, input: DataInputStream, delimIter: DelimiterIterator): Unit = {
+ protected def removeRightPadding(state: PState, input: DataInputStream, delimIter: DelimiterIterator): Unit = {
justificationTrim match {
case TextJustificationType.Center | TextJustificationType.Left if parsingPadChar.isDefined => {
- val rightPaddingRegister = TLRegistersPool.getFromPool("removeRightPadding")
- rightPaddingRegister.reset(finfo, input, delimIter)
+ val rightPaddingRegister = state.dfaRegistersPool.getFromPool("removeRightPadding")
+ rightPaddingRegister.reset(state, input, delimIter)
rightPadding.run(rightPaddingRegister)
- TLRegistersPool.returnToPool(rightPaddingRegister)
+ state.dfaRegistersPool.returnToPool(rightPaddingRegister)
}
case _ => // No right padding
}
}
- protected def parseStartBlock(finfo: FormatInfo, input: DataInputStream, startBlock: DFADelimiter, delimIter: DelimiterIterator): Boolean = {
- val startBlockRegister = TLRegistersPool.getFromPool("parseStartBlock")
- startBlockRegister.reset(finfo, input, delimIter)
+ protected def parseStartBlock(state: PState, input: DataInputStream, startBlock: DFADelimiter, delimIter: DelimiterIterator): Boolean = {
+ val startBlockRegister = state.dfaRegistersPool.getFromPool("parseStartBlock")
+ startBlockRegister.reset(state, input, delimIter)
startBlock.run(startBlockRegister) // find the block start, fail otherwise
val startStatus = startBlockRegister.status
- TLRegistersPool.returnToPool(startBlockRegister)
+ state.dfaRegistersPool.returnToPool(startBlockRegister)
startStatus match {
case StateKind.Succeeded => true // continue
case _ => false // Failed
@@ -226,15 +224,15 @@ class TextDelimitedParserWithEscapeBlock(
* Called to parse the rest of the field until we reach a block end, but
* beyond that, after we reach a block-end out until we reach the delimiter.
*/
- protected def parseRemainder(finfo: FormatInfo, input: DataInputStream,
+ protected def parseRemainder(state: PState, input: DataInputStream,
fieldEsc: DFAField,
startBlock: DFADelimiter, endBlock: DFADelimiter,
delimIter: DelimiterIterator, isDelimRequired: Boolean): Maybe[ParseResult] = {
val lmt = new LongestMatchTracker()
- val fieldRegister = TLRegistersPool.getFromPool("parseRemainder")
- fieldRegister.reset(finfo, input, delimIter)
+ val fieldRegister = state.dfaRegistersPool.getFromPool("parseRemainder")
+ fieldRegister.reset(state, input, delimIter)
var stillSearching: Boolean = true
var foundBlockEnd: Boolean = false
@@ -252,33 +250,33 @@ class TextDelimitedParserWithEscapeBlock(
case StateKind.Failed => stillSearching = false
case StateKind.Paused => {
// Pick up where field left off, we are looking for the blockEnd.
- val endBlockRegister = TLRegistersPool.getFromPool("parseRemainder2")
- endBlockRegister.reset(finfo, input, delimIter)
+ val endBlockRegister = state.dfaRegistersPool.getFromPool("parseRemainder2")
+ endBlockRegister.reset(state, input, delimIter)
endBlock.run(endBlockRegister)
val endBlockStatus = endBlockRegister.status
- TLRegistersPool.returnToPool(endBlockRegister)
+ state.dfaRegistersPool.returnToPool(endBlockRegister)
endBlockStatus match {
case StateKind.Succeeded => {
// Found the unescaped block end, now we need to
// find any padding.
- this.removeRightPadding(finfo, input, delimIter)
+ this.removeRightPadding(state, input, delimIter)
beforeDelimiter = input.markPos
delimIter.reset()
while (delimIter.hasNext()) {
// Finally, we can look for the delimiter.
val d = delimIter.next() // Pick up where end of block/padding left off
- val delimRegister = TLRegistersPool.getFromPool("parseRemainder3")
+ val delimRegister = state.dfaRegistersPool.getFromPool("parseRemainder3")
input.resetPos(beforeDelimiter)
beforeDelimiter = input.markPos
- delimRegister.reset(finfo, input, delimIter)
+ delimRegister.reset(state, input, delimIter)
d.run(delimRegister)
if (delimRegister.status == StateKind.Succeeded) {
lmt.successfulMatch(delimRegister.matchStartPos, delimRegister.delimString, d, delimIter.currentIndex)
}
- TLRegistersPool.returnToPool(delimRegister)
+ state.dfaRegistersPool.returnToPool(delimRegister)
}
foundBlockEnd = true
stillSearching = false
@@ -296,7 +294,7 @@ class TextDelimitedParserWithEscapeBlock(
//
input.resetPos(beforeDelimiter)
beforeDelimiter = DataInputStream.MarkPos.NoMarkPos
- fieldRegister.resetChars(finfo)
+ fieldRegister.resetChars(state)
// resume field parse
//
@@ -344,11 +342,11 @@ class TextDelimitedParserWithEscapeBlock(
}
}
- TLRegistersPool.returnToPool(fieldRegister)
+ state.dfaRegistersPool.returnToPool(fieldRegister)
result
}
- def parse(finfo: FormatInfo, input: DataInputStream, field: DFAField, fieldEsc: DFAField,
+ def parse(state: PState, input: DataInputStream, field: DFAField, fieldEsc: DFAField,
startBlock: DFADelimiter, endBlock: DFADelimiter,
delimIter: DelimiterIterator, isDelimRequired: Boolean): Maybe[ParseResult] = {
Assert.invariant(fieldEsc != null)
@@ -356,14 +354,14 @@ class TextDelimitedParserWithEscapeBlock(
Assert.invariant(startBlock != null)
Assert.invariant(endBlock != null)
- removeLeftPadding(finfo, input, delimIter)
- val foundStartBlock = parseStartBlock(finfo, input, startBlock, delimIter)
+ removeLeftPadding(state, input, delimIter)
+ val foundStartBlock = parseStartBlock(state, input, startBlock, delimIter)
val res = if (!foundStartBlock) {
- super.parse(finfo, input, field, delimIter, isDelimRequired)
+ super.parse(state, input, field, delimIter, isDelimRequired)
} else {
- parseRemainder(finfo, input, fieldEsc, startBlock, endBlock, delimIter, isDelimRequired)
+ parseRemainder(state, input, fieldEsc, startBlock, endBlock, delimIter, isDelimRequired)
}
- TLRegistersPool.pool.finalCheck
+ state.dfaRegistersPool.finalCheck
res
}
diff --git a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextDelimitedUnparser.scala b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextDelimitedUnparser.scala
index 6f7ddf2a7..bdd478fc1 100644
--- a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextDelimitedUnparser.scala
+++ b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextDelimitedUnparser.scala
@@ -86,7 +86,7 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
// We need to recognize the blockEnd in addition to the other pieces of
// text we should escape
//
- val fieldReg: Registers = TLRegistersPool.getFromPool("escapeBlock1")
+ val fieldReg: Registers = state.dfaRegistersPool.getFromPool("escapeBlock1")
val fieldEscapesIter = {
val ab = ArrayBuffer((blockEnd +: delims): _*)
@@ -128,7 +128,7 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
// We check for a blockEnd first, if it exists then we MUST
// generate an escape block
- val blockEndReg: Registers = TLRegistersPool.getFromPool("escapeBlock2")
+ val blockEndReg: Registers = state.dfaRegistersPool.getFromPool("escapeBlock2")
blockEndReg.reset(state, input, blockEndDelimIter)
blockEnd.run(blockEndReg)
val blockEndStatus = blockEndReg.status
@@ -136,7 +136,8 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
case StateKind.Succeeded if (!escapeEscapeChar.isDefined) => {
// Found an escapeEnd, which requires an escapeEscapeChar, but one was not provided
beforeDelimiter = DataInputStream.MarkPos.NoMarkPos
- UnparseError(One(context.schemaFileLocation),
+ UnparseError(
+ One(context.schemaFileLocation),
One(state.currentLocation),
"escapeEscapeCharacter was not defined but the escapeBlockEnd (%s) was present in the data.",
blockEnd.lookingFor)
@@ -171,7 +172,7 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
delimIter.reset()
while (delimIter.hasNext()) {
val d = delimIter.next()
- val delimReg: Registers = TLRegistersPool.getFromPool("escapeBlock3")
+ val delimReg: Registers = state.dfaRegistersPool.getFromPool("escapeBlock3")
input.resetPos(beforeDelimiter)
beforeDelimiter = input.markPos
delimReg.reset(state, input, delimIter)
@@ -187,7 +188,7 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
}
case _ => {
// this delim did not match, ignore it and discard its register
- TLRegistersPool.returnToPool(delimReg)
+ state.dfaRegistersPool.returnToPool(delimReg)
}
}
}
@@ -206,7 +207,7 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
val (_, matchedReg) = longestMatch(successes).get
val delim = matchedReg.delimString
fieldReg.appendToField(delim) // the delim just becomes field content, because we already had an escape block start.
- successes.foreach { case (d, r) => TLRegistersPool.returnToPool(r) }
+ successes.foreach { case (d, r) => state.dfaRegistersPool.returnToPool(r) }
successes.clear
shouldGenerateEscapeBlock = true
fieldReg.actionNum = 0
@@ -215,7 +216,7 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
// now go around the while loop again
} // end case StateKind.Failed for finding the block end.
} // end blockEndStatus.status match
- TLRegistersPool.returnToPool(blockEndReg)
+ state.dfaRegistersPool.returnToPool(blockEndReg)
} // end case StateKind.Paused for finding any of block end or a delimiter
} // end dfaStatus match
} // end while stillSearching
@@ -229,8 +230,8 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
// us to reuse the DFA for determining when to escape data while unparsing.
val resString = fieldReg.resultString.toString
- TLRegistersPool.returnToPool(fieldReg)
- TLRegistersPool.pool.finalCheck
+ state.dfaRegistersPool.returnToPool(fieldReg)
+ state.dfaRegistersPool.finalCheck
(resString, shouldGenerateEscapeBlock)
}
@@ -249,7 +250,7 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
Assert.invariant(field != null)
val successes: ArrayBuffer[(DFADelimiter, Registers)] = ArrayBuffer.empty
- val fieldReg: Registers = TLRegistersPool.getFromPool("escapeCharacter1")
+ val fieldReg: Registers = state.dfaRegistersPool.getFromPool("escapeCharacter1")
val delimIter = new AllDelimiterIterator(ArrayBuffer(delims: _*))
@@ -287,7 +288,7 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
delimIter.reset()
while (delimIter.hasNext()) {
val d = delimIter.next()
- val delimReg: Registers = TLRegistersPool.getFromPool("escapeCharacter2")
+ val delimReg: Registers = state.dfaRegistersPool.getFromPool("escapeCharacter2")
delimReg.reset(state, input, delimIter)
input.resetPos(beforeDelimiter)
beforeDelimiter = input.markPos
@@ -303,7 +304,7 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
}
case _ => {
// this delim did not match, ignore it and discard its register
- TLRegistersPool.returnToPool(delimReg)
+ state.dfaRegistersPool.returnToPool(delimReg)
}
}
}
@@ -335,7 +336,7 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
input.resetPos(beforeDelimiter)
Assert.invariant(input.skipChars(delim.length, state))
fieldReg.resetChars(state)
- successes.foreach { case (d, r) => TLRegistersPool.returnToPool(r) }
+ successes.foreach { case (d, r) => state.dfaRegistersPool.returnToPool(r) }
successes.clear
stillSearching = true
@@ -357,8 +358,8 @@ class TextDelimitedUnparser(override val context: TermRuntimeData)
// us to reuse the DFA for determining when to escape data while unparsing.
val resString = fieldReg.resultString.toString
- TLRegistersPool.returnToPool(fieldReg)
- TLRegistersPool.pool.finalCheck
+ state.dfaRegistersPool.returnToPool(fieldReg)
+ state.dfaRegistersPool.finalCheck
(resString, escapeOccurred)
}
diff --git a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextPaddingParser.scala b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextPaddingParser.scala
index 0941fc598..883a2b869 100644
--- a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextPaddingParser.scala
+++ b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextPaddingParser.scala
@@ -24,6 +24,7 @@ import org.apache.daffodil.processors.DelimiterIterator
import org.apache.daffodil.io.DataInputStream
import scala.collection.mutable.ArrayBuffer
import org.apache.daffodil.io.FormatInfo
+import org.apache.daffodil.processors.parsers.PState
class TextPaddingParser(val padChar: Char,
override val context: TermRuntimeData)
@@ -34,18 +35,18 @@ class TextPaddingParser(val padChar: Char,
val paddingDFA = CreatePaddingDFA(padChar, context)
- def parse(finfo: FormatInfo, input: DataInputStream, delimIter: DelimiterIterator): Maybe[ParseResult] = {
+ def parse(state: PState, input: DataInputStream, delimIter: DelimiterIterator): Maybe[ParseResult] = {
- val paddingReg: Registers = TLRegistersPool.getFromPool("TextPaddingParser1")
+ val paddingReg: Registers = state.dfaRegistersPool.getFromPool("TextPaddingParser1")
- paddingReg.reset(finfo, input, delimIter)
+ paddingReg.reset(state, input, delimIter)
paddingDFA.run(paddingReg) // Will always succeed.
val paddingValue = One(paddingReg.resultString.toString)
- TLRegistersPool.returnToPool(paddingReg)
- TLRegistersPool.pool.finalCheck
+ state.dfaRegistersPool.returnToPool(paddingReg)
+ state.dfaRegistersPool.finalCheck
One(new ParseResult(paddingValue, Nope, ArrayBuffer()))
}
diff --git a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextParser.scala b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextParser.scala
index 76f72bd58..ef9c13319 100644
--- a/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextParser.scala
+++ b/daffodil-runtime1/src/main/scala/org/apache/daffodil/processors/dfa/TextParser.scala
@@ -23,15 +23,15 @@ import org.apache.daffodil.processors.TermRuntimeData
import org.apache.daffodil.processors.DelimiterIterator
import org.apache.daffodil.io.DataInputStream
import org.apache.daffodil.io.FormatInfo
+import org.apache.daffodil.processors.parsers.PState
-class TextParser(
- override val context: TermRuntimeData)
+class TextParser(override val context: TermRuntimeData)
extends DFAParser {
override lazy val name: String = "TextParser"
override lazy val info: String = "" // Nothing additional to add here
- def parse(finfo: FormatInfo, input: DataInputStream, delimIter: DelimiterIterator, isDelimRequired: Boolean): Maybe[ParseResult] = {
+ def parse(state: PState, input: DataInputStream, delimIter: DelimiterIterator, isDelimRequired: Boolean): Maybe[ParseResult] = {
val lmt = new LongestMatchTracker()
@@ -39,14 +39,14 @@ class TextParser(
delimIter.reset()
while (delimIter.hasNext()) {
val d = delimIter.next()
- val reg = TLRegistersPool.getFromPool("TextParser1")
- reg.reset(finfo, input, delimIter, m)
+ val reg = state.dfaRegistersPool.getFromPool("TextParser1")
+ reg.reset(state, input, delimIter, m)
m = input.markPos
d.run(reg)
if (reg.status == StateKind.Succeeded) {
lmt.successfulMatch(reg.matchStartPos, reg.delimString, d, delimIter.currentIndex)
}
- TLRegistersPool.returnToPool(reg)
+ state.dfaRegistersPool.returnToPool(reg)
}
input.resetPos(m)
@@ -55,7 +55,7 @@ class TextParser(
if (isDelimRequired) Nope
else {
val totalNumCharsRead = 0
- input.getString(totalNumCharsRead, finfo)
+ input.getString(totalNumCharsRead, state)
One(new ParseResult(Nope, Nope, lmt.longestMatches))
}
} else {
@@ -66,7 +66,7 @@ class TextParser(
}
}
- TLRegistersPool.pool.finalCheck
+ state.dfaRegistersPool.finalCheck
result
}
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on 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