daffodil-lib/src/main/scala/org/apache/daffodil/lib/schema/annotation/props/ByHandMixins.scala (14 lines):
	- line 83: //       case AlignmentUnits.Bits => i // TODO: implement units * Units.bits
	- line 166: * FIXME: really we need to either eliminate separatorPolicy (deprecated name)
	- line 244: // TODO: must be single byte value entity
	- line 245: // TODO: must be single byte character
	- line 248: // TODO: must be a fixed-width encoding
	- line 267: // TODO: must be single byte value entity
	- line 268: // TODO: must be single byte character - means this can't be done statically like this.
	- line 272: // TODO: must be a fixed-width encoding
	- line 292: // TODO: must be single byte value entity
	- line 293: // TODO: must be single byte character
	- line 296: // TODO: must be a fixed-width encoding
	- line 315: // TODO: must be single byte value entity
	- line 316: // TODO: must be single byte character
	- line 319: // TODO: must be a fixed-width encoding


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/ElementBase.scala (13 lines):
	- line 285: enclosingElements.headOption // FIXME: DAFFODIL-2282 works only if there is no difference among usages.
	- line 294: myOwnNSPairs -- myParentNSPairs // FIXME: DAFFODIL-2282 works only if there is no difference among usages.
	- line 298: // FIXME: DAFFODIL-2282 works only if there is no difference among usages.
	- line 316: enclosingElements.headOption // FIXME: bug DAFFODIL-2282 doesn't work unless all are same.
	- line 690: // FIXME: there are lots of other cases where things are fixed length
	- line 701: // FIXME: this calculation only good for string type.
	- line 723: // FIXME: needs to work in lengthUnits. If length units is bytes/bits
	- line 742: // FIXME: shouldn't even be asking for this if not isFixedLength
	- line 744: // FIXME: needs to return fixed length in lengthUnits.
	- line 752: // FIXME: bless this method. Deprecate and remove other less reliable things.
	- line 1004: private val unbBD = new java.math.BigDecimal(-1) // TODO: should this be a tunable limit?
	- line 1090: // TODO: see code above that computes minLength, maxLength
	- line 1300: // TODO: Implement complex element defaulting


daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/ElementBaseGrammarMixin.scala (7 lines):
	- line 302: //        // TODO: do we have to consider utf-8 situation for strings when
	- line 361: lengthEv.optConstant.isDefined)) // TODO: consider if delimiters matter, alignment, nil values,.... Are we excluding
	- line 391: false // TODO: implement this
	- line 401: false // TODO: implement this
	- line 864: // TODO: Consider issues with matching a stopValue. Can't say isScalar here because
	- line 1307: prod("nilOrValue", isNillable) { // TODO: make it exclude emptyness once emptyness is implemented
	- line 1581: // TODO: this check is insisting on this being clear at compile time. But DFDL doesn't strictly speaking, require that.


daffodil-lib/src/main/scala/org/apache/daffodil/lib/util/Misc.scala (5 lines):
	- line 277: // TODO: no test coverage
	- line 424: val size = s.length() // TODO: get byte count by encoding
	- line 522: // TODO: this could go on and on. There's a flock of 'space' characters (EM SPACE)
	- line 525: // TODO: combining characters,
	- line 741: // TODO scala 2.12 phase out, we can remove the check for the plain name, and always


daffodil-runtime1-layers/src/main/scala/org/apache/daffodil/layers/runtime1/LineFoldedLayerBase.scala (5 lines):
	- line 96: * TODO: Doesn't enforce 998 max line length limit.
	- line 163: * TODO: Does not implement line-length limit of 998.
	- line 246: * TODO: Currently this normalizes isolated \n and \r to \r\n, which is not symmetric
	- line 258: //  TODO: To work properly this state machine needs more than just the line buffer as state. It needs to
	- line 377: // TODO: Implement check for punctuation immediately after the space or tab


daffodil-lib/src/main/scala/org/apache/daffodil/lib/xml/XMLUtils.scala (4 lines):
	- line 772: // TODO: actually check xsi:type attributes are correct according
	- line 779: // TODO: actually check xsi:type attributes are correct according
	- line 1046: // TODO: implement XML-comparison for our data format info PIs.
	- line 1614: //    // TODO: should this do something other than throw an exception on a validation error?


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/dfa/TextDelimitedParser.scala (4 lines):
	- line 96: // TODO: Please explain here why this is the way one resumes the field dfa?
	- line 97: // TODO: The above assignment to the actionNum is the only reason that actionNum can't just
	- line 136: // TODO: Performance - avoid this copying of the string. We should be able to trim
	- line 147: val str = fieldReg.resultString.toString // TODO: Performance see above.


daffodil-tdml-lib/src/main/scala/org/apache/daffodil/tdml/TDMLRunner.scala (4 lines):
	- line 482: // TODO: DAFFODIL-2410
	- line 2134: // TODO: We want this default to be false eventually.
	- line 2221: // TODO: add capability to specify character set encoding into which text is to be converted (all UTF-8 currently)
	- line 2826: // TODO: DAFFODIL-288 validate the infoset also


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dsom/CompiledExpression1.scala (3 lines):
	- line 61: * TODO: Consider - that an expression could be constant in some contexts, not others.
	- line 68: * TODO: provide enough scope information for this to optimize.
	- line 443: * TODO: Must eventually change to support query-style expressions where there


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dpath/DState.scala (3 lines):
	- line 269: // TODO: remove this code perhaps? This is demanded elsewhere....
	- line 367: // @inline // TODO: Performance maybe this won't allocate a closure if this is inline? If not replace with macro
	- line 377: final def withRetryIfBlocking[T](ds: DState)(body: => T): T = { // TODO: Performance maybe this won't allocate a closure if this is inline? If not replace with macro


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/EvTextNumber.scala (3 lines):
	- line 145: // TODO: this is allowed to be case insenstive, ICU doesn't support that
	- line 151: // TODO: this is allowed to be case insensitive, ICU doesn't support that
	- line 156: // TODO: this is allowed to be case insensitive, ICU doesn't support that


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/unparsers/UState.scala (3 lines):
	- line 278: // TODO: Figure out why this setPriorBitOrder is needed here.
	- line 597: new ByteArrayOutputStream() // TODO: PERFORMANCE: Allocates new object. Can reuse one from an onStack/pool via reset()
	- line 683: // TODO: it doesn't look anything is actually reading the value of childindex


daffodil-lib/src/main/scala/org/apache/daffodil/lib/util/Coroutines.scala (3 lines):
	- line 221: // TODO: no test coverage
	- line 234: // TODO: no test coverage
	- line 239: // TODO: no test coverage


daffodil-runtime1-unparser/src/main/scala/org/apache/daffodil/unparsers/runtime1/SeparatedSequenceUnparsers.scala (3 lines):
	- line 190: * FIXME: this function is not used anywhere and appears to be dead code.
	- line 211: //  // TODO: merge these two objects. We can allocate just one thing here.
	- line 257: // TODO: merge these two objects. We can allocate just one thing here.


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/infoset/InfosetImpl.scala (3 lines):
	- line 711: // TODO: assert check for length in bytes makes sense - length units is bytes, or is characters, but characters
	- line 1159: initialSize: Int // TODO: really this needs to be adaptive, and resize upwards reasonably.
	- line 1162: // FIXME: for streaming behavior, arrays are going to get elements removed from


daffodil-lib/src/main/scala/org/apache/daffodil/lib/xml/QNameBase.scala (3 lines):
	- line 196: // TODO: where we parse xmlSchemaDocument, a check for
	- line 598: // x370_37D + // TODO: why is this one is left out? Add comments please.
	- line 603: // TODO: why are the above left out? Add comments please.


daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/Production.scala (2 lines):
	- line 85: new NadaParser(context.runtimeData) // TODO: detect this and remove from final parser
	- line 100: ) // TODO: detect this and remove from final unparser


daffodil-codegen-c/src/main/scala/org/apache/daffodil/codegen/c/generators/CodeGeneratorState.scala (2 lines):
	- line 184: // TODO: not covered by tests
	- line 298: // TODO: not covered by tests


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/RuntimePropertyMixins.scala (2 lines):
	- line 76: * TODO: EscapeScheme's have a few more of these runtime properties
	- line 711: *  TODO: An improvement - the enclosing sequence object should really be


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/PropProviders.scala (2 lines):
	- line 58: // TODO: optimize by having this object actually check if there
	- line 158: // TODO: Check for circularity if schema validation doesn't.


daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/AlignedMixin.scala (2 lines):
	- line 137: // FIXME: DAFFODIL-2295
	- line 147: ) // root and quasi elements are aligned with anything // TODO: really? Why quasi-elements - they should have implicit alignment ?


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/DFDLDelimiter.scala (2 lines):
	- line 82: // TODO: Maybe should have an error message for the example.  What did they mean?
	- line 374: // therefore treat as a CharDelim (TODO: Why? Seems like the throw below commented out is more correct.)


daffodil-propgen/src/main/scala/org/apache/daffodil/propGen/PropertyGenerator.scala (2 lines):
	- line 99: * TODO: move to some utilities library
	- line 809: // TODO: This is not the modern way to do this. Update this to use the getResource technique used


daffodil-io/src/main/scala/org/apache/daffodil/io/DataOutputStreamImplMixin.scala (2 lines):
	- line 906: // TODO: restore mandatory alignment functionality.
	- line 920: // TODO: data size limit. For utf-8, this will limit the max number of chars


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/DataProcessor.scala (2 lines):
	- line 375: // TODO: ideally we could create a validator that validates using only SAX
	- line 652: // TODO: revisit this in light of API changes that allow a series of calls


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/Facets.scala (2 lines):
	- line 254: // TODO: Tidy up.  Can likely replace getFacetValue with a similar call to combinedBaseFacets
	- line 652: // TODO: I think the performance here can be improved.


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dpath/DPath.scala (2 lines):
	- line 96: // TODO: fix this check below. There is a universe of target types which is
	- line 220: // TODO: This assumes a distinct state object (with its own dState) for every expression that


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/parsers/PState.scala (2 lines):
	- line 130: // TODO: it doesn't look anything is actually reading the value of childindex
	- line 484: // TODO: This looks like a lot of overhead for every single parse call.


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/unparsers/Unparser.scala (2 lines):
	- line 40: // ?? TODO: Should this be after the split below ??
	- line 43: // TODO: Remove this call to ustate.bitOrder below.


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/Term.scala (2 lines):
	- line 210: * TODO: it does have to deal with the prefix length situation. The type of the prefix
	- line 217: // TODO: if we add recursive types capability to DFDL this will have to change


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/dfa/CreatePaddingDFA.scala (2 lines):
	- line 31: // TODO: In the future we will need to change this because the padChar isn't necessarily a char.
	- line 53: // TODO: In the future we will need to change this because the padChar isn't necessarily a char.


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/Suspension.scala (2 lines):
	- line 50: * TODO: Redundant with implementing maybeKnownLengthInBits as MaybeULong(0L)
	- line 178: // TODO: Performance - copying this whole state, just for OVC is painful.


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/parsers/StringLengthParsers.scala (2 lines):
	- line 76: // TODO: this is a hack, it doesn't actually set the correct start/end
	- line 100: // TODO: Performance - trimByJustification wants to operate on a StringBuilder


daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/primitives/PrimitivesLengthKind.scala (2 lines):
	- line 118: // TODO: move out of parser and into the dsom
	- line 123: // TODO: move out of parser and into the dsom


daffodil-runtime1-unparser/src/main/scala/org/apache/daffodil/unparsers/runtime1/ElementUnparser.scala (2 lines):
	- line 217: ??? // TODO: JIRA DFDL-1582 - Is the ticket for implementing the Unparser - validation feature
	- line 693: // TODO: Performance: Ideas: maybe each unparse should sport a captureRuntimeValueProperties, and


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dpath/DFDLCheckConstraintsFunction.scala (1 line):
	- line 20: // TODO: replace these with our own Infoset implementation objects


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dpath/FNFunctions.scala (1 line):
	- line 397: ) // TODO: Remove eventually. Holdover from JDOM where everything is a string.


daffodil-lib/src/main/scala/org/apache/daffodil/lib/util/Timer.scala (1 line):
	- line 190: * TODO: not covered by tests


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/dfa/Rules.scala (1 line):
	- line 391: ) // TODO: Performance - this should be determined at schema-compilation time.


daffodil-lib/src/main/scala/org/apache/daffodil/lib/externalvars/Binding.scala (1 line):
	- line 129: // FIXME: Should not be catching throwable here.


daffodil-io/src/main/scala/org/apache/daffodil/io/processors/charset/BitsCharsetDecoder.scala (1 line):
	- line 121: // MaybeChar.Nope // TODO: should this rethrow the exception instead? So callers of decode must determine how to handle decode errors


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/infoset/InfosetWalker.scala (1 line):
	- line 454: // FIXME: DAFFODIL-2884 This escalates a parser data exception to an SDE


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/parsers/ElementCombinator1.scala (1 line):
	- line 124: // TODO: Performance/Maintainability - get rid of use of return statements.


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/DFDLProperty.scala (1 line):
	- line 63: // TODO: if we grab the value from here, then any qnames inside that value


daffodil-io/src/main/scala/org/apache/daffodil/io/processors/charset/BitsCharsetNonByteSize.scala (1 line):
	- line 124: * TODO: Similar to our decoders, we should create custom encoders. Then we


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/parsers/DelimitedParsers.scala (1 line):
	- line 73: // TODO: DFDL-451 - Has been put on the backburner until we can figure out the appropriate behavior


daffodil-lib/src/main/scala/org/apache/daffodil/lib/Implicits.scala (1 line):
	- line 47: // TODO: move these to TestUtils object in daffodil-lib-unittest


daffodil-runtime1-unparser/src/main/scala/org/apache/daffodil/unparsers/runtime1/SpecifiedLength2.scala (1 line):
	- line 417: ??? // FIXME: This code was left incomplete - JIRA DAFFODIL-1952


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dpath/DPathRuntime.scala (1 line):
	- line 81: * TODO: constant folding really should operate on sub-expressions of expressions


daffodil-io/src/main/scala/org/apache/daffodil/io/RegexLimitingInputStream.scala (1 line):
	- line 58: targetChunkSize: Int = 32 * 1024 // TODO: should this be smaller? Limited by a tunable?


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/infoset/PartialNextElementResolver.scala (1 line):
	- line 181: // TODO: PERFORMANCE: We really should be interning all QNames so that comparison of QNames can be pointer equality


daffodil-io/src/main/scala/org/apache/daffodil/io/StringDataInputStreamForUnparse.scala (1 line):
	- line 42: // TODO: This only works for Java charsets, we should really use our own


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/parsers/NilMatcherMixin.scala (1 line):
	- line 139: // TODO: does this handle %ES; or do we have to have outside separate checks for that?


daffodil-io/src/main/scala/org/apache/daffodil/io/Dump.scala (1 line):
	- line 659: // FIXME: This will be really broken for EBCDIC-based encodings. Pass the encoding


daffodil-io/src/main/scala/org/apache/daffodil/io/DataInputStream.scala (1 line):
	- line 30: * TODO:


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/ModelGroup.scala (1 line):
	- line 269: * FIXME: DAFFODIL-2132. This tells us if framing is expressed on the schema.


daffodil-runtime1-unparser/src/main/scala/org/apache/daffodil/unparsers/runtime1/StringLengthUnparsers.scala (1 line):
	- line 158: // TODO: PERFORMANCE:


daffodil-lib/src/main/scala/org/apache/daffodil/lib/schema/annotation/props/Properties.scala (1 line):
	- line 207: // TODO DFDL String Literal processing to deal with


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/ProcessorBases.scala (1 line):
	- line 143: // TODO: make this create a DOM tree, not a single string (because of size limits)


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dpath/NodeInfo.scala (1 line):
	- line 219: // FIXME: this scope has xs prefix bound, but what if that's not the binding


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/RestrictionUnion.scala (1 line):
	- line 516: // TODO: NegativeInteger not supported in DFDL v1.0


daffodil-lib/src/main/scala/org/apache/daffodil/lib/schema/annotation/props/PropertyScoping.scala (1 line):
	- line 218: // TODO: Internationalization - should not be assembling error messages in English like this.


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/infoset/InfosetOutputter.scala (1 line):
	- line 142: * FIXME: Scaladoc


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/ChoiceGroup.scala (1 line):
	- line 123: // else if (isKnownToBeAligned) true //TODO: Alignment may not occur; hence, cannot be part of determining whether there is known syntax.


daffodil-io/src/main/scala/org/apache/daffodil/io/DirectOrBufferedDataOutputStream.scala (1 line):
	- line 404: // TODO: PERFORMANCE: This is very pessimistic. It's making a complete clone of the state


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/debugger/InteractiveDebugger.scala (1 line):
	- line 422: // TODO: it would be good to know if this bp name is ambiguous


daffodil-lib/src/main/scala/org/apache/daffodil/lib/util/MStack.scala (1 line):
	- line 131: * TODO: Note: Maybe or other Value classes (derived from AnyVal). Currently


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dpath/ConverterOps.scala (1 line):
	- line 284: // TODO: Once sequences are supported, fill in these case statements


daffodil-core/src/main/scala/org/apache/daffodil/core/dpath/Expression.scala (1 line):
	- line 95: * TODO: get more precise line and column information for


daffodil-schematron/src/main/resources/iso-schematron-xslt2/iso_schematron_skeleton_for_saxon.xsl (1 line):
	- line 214: * RJ Fix up warning on looking for @* on root  TODO CHECK!!!!


daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/primitives/PrimitivesExpressions.scala (1 line):
	- line 139: // TODO: performance wise, initiated content is supposed to be faster


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/Import.scala (1 line):
	- line 58: // FIXME: if you have an import like this:


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/LocalElementMixin.scala (1 line):
	- line 88: // TODO: It is possible that this initiator expression cannot match zero length


daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/primitives/PrimitivesDelimiters.scala (1 line):
	- line 107: // TODO: DFDL-451 - After conversing with Mike B. about this, we're putting this on the backburner.


daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/TermGrammarMixin.scala (1 line):
	- line 41: // TODO: replace dfdlScopeBegin and dfdlScopeEnd with a single Combinator.


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dpath/UpDownMoves.scala (1 line):
	- line 69: // TODO PE ? if doesn't exist should be a processing error.


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/EvEncoding.scala (1 line):
	- line 68: // TODO: Use byte order mark (from P/UState or another EV?) to determine


build.sbt (1 line):
	- line 479: // FIXME: DAFFODIL-2902


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dpath/FNBases.scala (1 line):
	- line 227: // FIXME: rewrite to use an OnStack ListBuffer, and


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/dpath/DFDLFunctions2.scala (1 line):
	- line 44: // TODO: We could warn about taking lengthInCharacters of something


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/VariableMap1.scala (1 line):
	- line 454: * TODO: This should be an SDE, but due to a bug (DAFFODIL-1443) in


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/parsers/UnseparatedSequenceChildParseResultHelper.scala (1 line):
	- line 24: * TODO: Consider merge of these helpers into the parser classes so we don't have


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/parsers/SpecifiedLengthParsers.scala (1 line):
	- line 217: // TODO: Performance - if the encoding is an expression, but that


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/dfa/TextDelimitedUnparser.scala (1 line):
	- line 165: // TODO: scrutinize DFA code. Why does appendToField call commitOneChar anyway?


daffodil-runtime1-unparser/src/main/scala/org/apache/daffodil/unparsers/runtime1/LayeredSequenceUnparser.scala (1 line):
	- line 49: // TODO: we're not unparsing here, just writing bytes, so perhaps we do not


daffodil-runtime1-unparser/src/main/scala/org/apache/daffodil/unparsers/runtime1/ExpressionEvaluatingUnparsers.scala (1 line):
	- line 50: * TODO: Possible bug. This will allow expressions to forward reference, even


daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/ProcessorStateBases.scala (1 line):
	- line 505: // TODO: many off-by-one errors due to not keeping strong separation of


daffodil-runtime1-layers/src/main/scala/org/apache/daffodil/layers/runtime1/FixedLengthLayer.scala (1 line):
	- line 37: * TODO: Someday, enhance to make this streaming.


daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/SchemaComponent.scala (1 line):
	- line 90: // FIXME: I think this should be abstract. We never need this actual object.


daffodil-io/src/main/scala/org/apache/daffodil/io/processors/charset/CharsetUtils.scala (1 line):
	- line 113: // TODO: Cleanup - change below to use NonAllocatingMap to improve code style.


daffodil-core/src/main/scala/org/apache/daffodil/core/runtime1/TermRuntime1Mixin.scala (1 line):
	- line 624: // TODO: Performance: could be improved, as there are situations where byteOrder