daffodil.git
6 years agoAdd missing copyrights
Steve Lawrence [Fri, 29 Jul 2016 18:17:48 +0000 (14:17 -0400)] 
Add missing copyrights

6 years agoModify PCAP schema to unparse more correctly
Steve Lawrence [Wed, 27 Jul 2016 17:06:52 +0000 (13:06 -0400)] 
Modify PCAP schema to unparse more correctly

- Remove the PayloadLength element. This element is used in an explicit
  length property, and is an inputValueCalc element that references an
  outputValueCalc element. This causes problems on unparse because the
  inputValueCalc element is not reevaluated on unparse, the explicit
  length used is not correct. The explicit length we want used is the
  outputValueCalc value on unparse, not whatever was calculated on
  inputValueCalc on parse. We really want to use a variable here, but
  the not-yet-implemented newVariableIntance is required. Instead, just
  have elements that referenced PayloadLength reference the specific
  elements they need. Note that this means an explicit length elements
  now reference outputValueCalc elements, which causes a chicken/egg
  problem. Disable the PCAP unparse test until that is resolved.
- Simplify the outputValueCalc expressions for determining
  IPSrc/DestBytes. Something broke at some point and the expression was
  too difficult to debug.
- Add outputValueCalc for Ethertype based on the existence of the IPv4
  or IPv6 elements
- Add an outputValueCalc for IPv4 protocol based on existance of TCP/UDP
  elements

6 years agoAdded infoset DIElement members for valueLength state.
Mike Beckerle [Wed, 20 Jul 2016 13:58:12 +0000 (09:58 -0400)] 
Added infoset DIElement members for valueLength state.

Refactored to share common code between valueLength and contentLength.

Refactored SuspendableExpression to have Suspension base.

Reorganized Suspension to have separate objects MainCoroutine and
TaskCoroutine which resume each other, to make things clearer, rather
than the Suspension object itself being the main coroutine.

Created SuspendableOperation - simpler to use in many situations than
Suspendable Expression.

AlignmentFillUnparser blocks until the absolute bit position needed to
perform alignment is known.

Added testOutputValueCalcVariableLengthThenAlignmentDeadlock.

Simplified SpecifiedLength prims and processors.

There was a proliferation of things to deal with in the runtime. Now
just 4 concrete specifiedLength prims and parser/unparsers are needed.

DFDL-1342, DFDL-1567, DFDL-1568, DFDL-1557

6 years agoUpdated for tests section23/dfdl_expressions/TestDFDLExpressionsDebug.scala test...
David Thompson [Tue, 12 Jul 2016 18:47:03 +0000 (14:47 -0400)] 
Updated for tests section23/dfdl_expressions/TestDFDLExpressionsDebug.scala test test_lowercase_05 now longer fails and passes round trip test.

DFDL-1078

6 years agoAdding tests for unparsers for binary numbers with fixed size
Beth Finnegan [Fri, 22 Jul 2016 14:51:43 +0000 (10:51 -0400)] 
Adding tests for unparsers for binary numbers with fixed size

DFDL-1365

6 years agoDo not abort when dumping utf-16/32 data
Steve Lawrence [Thu, 21 Jul 2016 14:23:00 +0000 (10:23 -0400)] 
Do not abort when dumping utf-16/32 data

We currently abort when outputing utf-16/32 data because the byte order
mark is required the to know how to properly output the data. Except the
DFDL spec says that if no byte order mark exists, then to use the big
endian encoding. Daffodil does not support byte order marks, so it just
always uses the big endian encoding when the encoding is specified as
utf-16.

So, when dumping utf-16 data, it is consistent with the rest of Daffodil
to use the normal java utf-16 encoder, which will default to utf-16be.
Note that this will eventually need to change when we do add support for
BOM so that the encoder takes that into account.

DFDL-1402

6 years agoAdd tunable to control how unqualified path steps are resolved
Steve Lawrence [Wed, 20 Jul 2016 13:04:33 +0000 (09:04 -0400)] 
Add tunable to control how unqualified path steps are resolved

Add a new tunable, unqualifiedPathStepPolicy to control how we resolve
unqualfied path steps, allowing for flexibility and interoperability
with different XML methods of handling such cases. The three options
are:

1) noNamespace

    Require a prefix for path steps if an element is qualified. If
    an element is unqualfied, then there must not be a prefix on the
    path step. Prefixes are always required with this method.

2) defaultNamespace

    If a path step is unqualified, then assume the default namespace.
    This allows schema authors to leave off prefixes if all elements are
    in the default namespace. Note that this could cause issues when
    elementFormDefault="unqualified" since there is no way to reference
    an unqualified element.

3) preferDefaultNamespace

    Similar to defaultNamespace, assume the default namespace if a path
    step is unqualified. However, if that fails to resolve to an
    element, then attempt to resolve using NoNamespace. Similar to
    defaultNamespace, this allows schema authors to leave off prefixes,
    but works better when elementFormDefault="unqualified" because also
    resolves to elements in NoNamespace.

Additionally, this moves DaffodilTunableParamters to daffodil-lib, since
QName resolution code in daffodil-lib uses the new tunable.

Also fix a bug where a namespace definition with NoNamespace was output
as xmlns="No_Namespace" rather than xmlns="".

DFDL-1446

6 years agoFix how dfdl:inputValueCalc elements are used in determining next elements
Steve Lawrence [Fri, 15 Jul 2016 17:02:02 +0000 (13:02 -0400)] 
Fix how dfdl:inputValueCalc elements are used in determining next elements

- Previously, inputValueCalc elements were treated as optional in the
  infoset in terms of the next element resolver used in unparsing. This
  resulted in some odd behaviors and could potentialy introduce
  ambiguities during unparsing. This change treats IVC's as optional and
  removes any ambiguities.

DFDL-1347

6 years agoMoved TestSequenceGroupUnparse from scala-new to scala.
David Thompson [Wed, 20 Jul 2016 18:20:30 +0000 (14:20 -0400)] 
Moved TestSequenceGroupUnparse from scala-new to scala.

DFDL-1550

6 years agoMoved test(s) from TestNillableNew.scala to TestNillable.scala.
David Thompson [Wed, 20 Jul 2016 17:23:28 +0000 (13:23 -0400)] 
Moved test(s) from TestNillableNew.scala to TestNillable.scala.
Moved test(s) from TestNillableUnparseNew.scala to TestNillableUnparse.scala.
Corrected schema and test in literal-character-nils-unparse.tdml.
Added additional test to literal-character-nils-unparse.tdml.

DFDL-1550

6 years agoRemove MaxPermSize option in daffodil CLI script
Steve Lawrence [Tue, 19 Jul 2016 14:51:19 +0000 (10:51 -0400)] 
Remove MaxPermSize option in daffodil CLI script

- JEP 122 "Removed the permanent generation from the Hotspot JVM and
  thus the need to tune the size of the permanent generation." The
  MaxPermSize option now results in a deprecation message, so remove the
  option from the daffodil CLI.

DFDL-1393

6 years agoImprove unexpected event error messages
Steve Lawrence [Tue, 19 Jul 2016 11:40:48 +0000 (07:40 -0400)] 
Improve unexpected event error messages

- Make unexpected event error messages more consistent
- Modify event toString method to make themmore human friendly

DFDL-1301

6 years agoThrow an exception rather than an SDE when the Java version is wrong
Steve Lawrence [Fri, 15 Jul 2016 15:27:54 +0000 (11:27 -0400)] 
Throw an exception rather than an SDE when the Java version is wrong

- This way, the CLI or any users can catch this exception and handle it
  appropriately. In the case of the CLI, we can print out a nice message
  rather than printing out the "You've found a bug" message.

DFDL-1374

6 years agoImplement error message when a sibling element is found as a child of a simple element
Steve Lawrence [Fri, 15 Jul 2016 12:16:20 +0000 (08:16 -0400)] 
Implement error message when a sibling element is found as a child of a simple element

For example, imagine we expected:

  <root>
    <foo>A</foo>
    <bar>B</bar>
  </root>

but instead we got the following.

  <root>
    <foo>
      <bar>X</bar>
    </foo>
  </root>

In this case, the next element resolver would actually successfully find
bar, but then throw an error that haden't been implemented yet. This
implements that function. This also removes an unused error function.

DFLD-1311

6 years agoAdd support for daf:parseUnparsePolicy
Steve Lawrence [Tue, 5 Jul 2016 13:17:53 +0000 (09:17 -0400)] 
Add support for daf:parseUnparsePolicy

This daffodil extension property determines whether or not we should
build a parser, an unparser, or both. Valid values for this property are
"parseOnly", "unparseOnly", or "both". This is used to determine if
Daffodil should build a parser, an unparser, or both. Additionally,
disables SDE checking that are specific parse or unparse if either are
disabled. This property can be used like so:

First define the daf extension namespace:

  xmlns:daf="urn:ogf:dfdl:2013:imp:opensource.ncsa.illinois.edu:2012:ext"

Then set the property simliar to how normal dfdl properties are set, but
include the daf prefix:

  <dfdl:format daf:parseUnparsePolicy="parseOnly" ... />

  <xs:element daf:parseUnparsePolicy="parseOnly" ... />

  <xs:annotation>
    <xs:appinfo source="http://www.ogf.org/dfdl/">
      <dfdl:element>
        <daf:property name="parseUnparsePolicy">parseOnly</daf:property>
      </dfdl:element>
    </xs:appinfo>
  </xs:annotation>

Note that to use the element form, the property element is in the daf
namespace.

To determine what should be be built and checked, we look at the
parseUnparsePolicy of the root element. All children elements must have
a compatible parseUnparsePolicy or it is a SDE. For a child element to
be compatible, it must either have the same parseUnparsePolicy as the
parent, or it must have a "both" parseUnparsePolicy.

This also adds a tunable (parseUnparsePolicy) that can have values of
'parseOnly', 'unparseOnly', 'both', or 'schema'. If the value is
'schema' (the default value), then the policy is determined by looking
at the root element. Otherwise, the root element is ignored and the
value of the tunable is used. All children, including the root, must be
compatible with the tunable policy if it is not 'schema'.

Also modify AG and AM test to use this new property to only support
parsing, since these tests are not worth the effort or can't possibly be
made to support unparsing.

DFDL-1564

6 years agoAdd Scala and Java APIs for unparsing
Steve Lawrence [Thu, 7 Jul 2016 12:46:32 +0000 (08:46 -0400)] 
Add Scala and Java APIs for unparsing

- Modify Scala and Java APIs to support unparsing
- Modified Scala/Java API tests to round trip tests where possible.
  Additionally, many tests were modified to clean up unused code to make
  the tests seem less cluttered
- Revealed an issue in the Java API where we double HTML-escaped the
  data. This resulted in things like &amp;lt; in the data, instead of
  just &lt;. This happened because when creating a JDOM2 documented, we first
  convert the infoset to a scala.xml.Node, then convert that to JDOM2.
  Scala escape the data, and then JDOM escaped the data again. The
  solution is to just get the raw data out of the scala Nodes and
  provide those to JDOM.
- Slightly change the logic for converting CRLF to LF. The way we had
  it, when writing to XML, it would convert CRL to LF correctly. But
  when reading XML that contained CRLF, it would be converted to CR.
  Fixing the logic resolves this issue.
- Change InfosetCursor.fromXMLNode to create and XMLEventCurosr rather
  than using elem2Element. The elem2Element function aborts if the scala
  xml does not match the infoset. We need to report SDE's if they do not
  match, so instead use XMLUtils.nodeToXMLEventCursor to convert the
  node to an XMLEventCursor, which is then used to create an
  InfostCursor.

DFDL-1250
DFDL-1251

6 years agoAfter verifying moved tests fillByte_01 - fillByte_06 for TestAlignedDataNew.scala...
David Thompson [Fri, 8 Jul 2016 15:43:34 +0000 (11:43 -0400)] 
After verifying moved tests fillByte_01 - fillByte_06 for TestAlignedDataNew.scala to TestAlignedData.scala.

DFDL-1426

6 years agoMoved test AG000 - AG001 from daffodil-test-ibm1/src/test/scala-new/edu/illinois...
David Thompson [Tue, 5 Jul 2016 16:24:14 +0000 (12:24 -0400)] 
Moved test AG000 - AG001 from daffodil-test-ibm1/src/test/scala-new/edu/illinois/ncsa/daffodil/TresysTests3.scala to daffodil-test-ibm1/src/test/scala/edu/illinois/ncsa/daffodil/TresysTests.scala after verifying. ref. ticket 1553.

6 years agoFix unparsing complex elements in hidden groups
Steve Lawrence [Fri, 1 Jul 2016 11:49:44 +0000 (07:49 -0400)] 
Fix unparsing complex elements in hidden groups

- Hidden elements will never result in infoset events. So do not try to
  consume events when the element is hidden. Only do that for non-hidden
  elements.
- Because hidden elements do not create events, InfosetElements are also
  never created. So for hidden elements, manually create an
  InfosetElement and set it as the current node. This allows expressions
  to reference those elements and ensure child elements are added to the
  correct InfosetElement.
- For the StatementElementOVCUnparser, do not always create a new
  DISimple. Since OVC elements are optional in the infoset, events for
  they may or may not exist. If they do exist, there will be an event,
  and we can use the infoset element the event creates. If they do not
  exist, either because they were not in the infoset or because they
  where hidden, then create the DISimple infoset element. Note that the
  existing infoset element needs to be reset since we don't want it to
  ever have a value unless it's been calculated. A resetValue function
  is added to remove its value.
- Improve error checking for non-hidden elements to ensure we get
  not only a start event, but a start event for the correct ERD.

DFDL-1552

6 years agoWrite infosets with namespaces that the unparser expects
Steve Lawrence [Thu, 30 Jun 2016 17:21:42 +0000 (13:21 -0400)] 
Write infosets with namespaces that the unparser expects

Before this change, some tests with complex namespaces would result in
an infoset that did not match what the unparse expected. These changes
fix that issue:

- Modify how minimized scope is calculated. The existing code was mostly
  correct, but missed some edge cases where the same namespace prefix
  was changed to a different namespaces by a child element. This
  happened most often with the default namespace (i.e. xmlns="foo").
  This patch adds support for detecting when these namesspace prefix
  changes happen (including default namespace changes) resulting in a
  correct minimized scope.

- Modify the toWriter methods of the InfosetImpl to perform pretty
  printing. This does not add whitespace inside of simple elements.
  It only adds indentation and newlines where it does not affect the
  data. Also replace uses of the PrettyPrinter in the debugger and
  runtime with the toWriter method. The PrettyPrinter tried to do some
  complex work to hide namespaces that were not necessary to show, but
  it didn't have all the necessary information (like parent namespace)
  and would sometimes create invalid namespaces. The InfosetImpl has
  all the necessary information, so it is much easier for it to just
  pretty print the infoset. Additionally, if someone wants a pretty
  string, this avoids create a Scala NodeSeq and then using a pretty
  printer to convert to a string.

- Remove the uniqueScope namespace binding variable. This didn't
  actually result in the correct namespace for the examples mentioned.
  Instead, a new method is added to create a string for the unique
  scope, based on the current scope and the parent scope. Unique scopes
  are just those that are in the current scope but not in the parent

DFDL-1555

6 years agoPreserve relative and absolute bit positions when converting buffered to direct DOS
Steve Lawrence [Wed, 29 Jun 2016 17:40:29 +0000 (13:40 -0400)] 
Preserve relative and absolute bit positions when converting buffered to direct DOS

- When converting a buffered DOS to direct DOS, the relative bit
  position in the old direct DOS needs to become the relative bit
  position for the new direct DOS. This is because the new direct DOS,
  which used to be a buffered DOS, had a bit position relative to its
  beginning, not the beginning of the data. Similarly, the absolute bit
  position and relative bit limit must be preserved as well. This fixes
  a bug where the final bit position does not match that actual bytes
  that were written.
- Modify the TDMLRunner to validate that the number of bytes written to
  the unparse output stream match that final bit position.
- Set tests to round trip now that this bug is fixed

DFDL-1553

6 years agoChange fillByte to an Evaluatable
Steve Lawrence [Tue, 28 Jun 2016 23:03:57 +0000 (19:03 -0400)] 
Change fillByte to an Evaluatable

- Support fill bytes that use a character and runtime value encoding.
- Move fill byte out of the RuntimeData. Only two unparsers really need
  this (hexbinary and string unparsers), so this saves a little space in
  RuntimeData.
- Add tests to ensure fillByte the error cases are checked (e.g.
  multi-byte character, non-byte size characters, fill byte with more
  than one charcter, etc.)

DFDL-1558
DFDL-1426

6 years agoFixes for eclipse user setup.
Mike Beckerle [Tue, 28 Jun 2016 20:35:29 +0000 (16:35 -0400)] 
Fixes for eclipse user setup.

DFDL-1562

6 years agoSupport roundtrip in sections 15, 16, 23, & Other
Steve Lawrence [Tue, 28 Jun 2016 18:12:50 +0000 (14:12 -0400)] 
Support roundtrip in sections 15, 16, 23, & Other

- Remove the backtracking test. It was redundant with PCAP tests, which
  already have duplication.
- If possible, modify TDML tests to round trip without changing the
  intention of the test.
- Set the defaultRoundTripDefaultDefault to true so that, unless
  otherwise specified, all tests will be run round trip. As of this
  commit, all tests either round trip successfully, or have explicit set
  roundTrip="false" because they are not meant to round trip or there is
  a bug preventing them from round tripping.

DFDL-1551

6 years agoRemove unused debug file that broke the build due to unused imports
Steve Lawrence [Tue, 28 Jun 2016 19:59:09 +0000 (15:59 -0400)] 
Remove unused debug file that broke the build due to unused imports

6 years agoSupport roundtrip in sections 13 & 14
Steve Lawrence [Tue, 28 Jun 2016 16:23:54 +0000 (12:23 -0400)] 
Support roundtrip in sections 13 & 14

- Differentiate between unparse a literalValueNil and a
  literalCharacterNil. With literalCharacterNil, we need to unparse the
  literal character, but also fill the specified length with that
  character. To accomplish this, this modifies how the pad character is
  calculated and the pad character for literalCharacterNil is set to the
  nil character. Thus, the specified length is just padded with the nil
  character.
- If possible, modify TDML tests to support roundTripping without
  changing the intention of the test.
- Also, DFDL-1304 appears to be fixed now. This was not fixed as part of
  this patchset (it's unclear where it was fixed), but the tests are now
  enabled.

DFDL-1550
DFDL-1304

6 years agoSupport roundtrip in sections 8, 10, 11, and 12
Steve Lawrence [Tue, 28 Jun 2016 13:49:43 +0000 (09:49 -0400)] 
Support roundtrip in sections 8, 10, 11, and 12

- Remove the StringLengthPatternUnparser. When unparsing, patterns are
  not used to determine length. Instead, the string is just written with
  no padding or fill, and is truncated if necessary. The
  SpecifiedLengthUnparser is modified to take a parameter that specifies
  if it is for a pattern length string and, if so, disables
  padding/fill.
- Modify TDML tests to support roundTrip="true" without changing the
  intention of the test. Some tests were set to roundTrip="false" if
  more involved changes to Daffodil are required.

DFDL-1549
DFDL-1538

6 years agoSupport roundtripping for sections 6 & 7
Steve Lawrence [Mon, 27 Jun 2016 17:52:55 +0000 (13:52 -0400)] 
Support roundtripping for sections 6 & 7

- When converting for XML output, do not blindly convert CR to LF. The
  rule is to convert CRLF to a single LF. Otherwise convert CR to LF.
  Otherwise, CRLF is converted to LFLF, which causes roundtripping
  issues.
- When determining the encoding, never actually use UTF-16 or UTF-32.
  Instead, we should determine what the byte order mark is and use the
  appropriate UTF-16{BE,LE}. If BOM doesn't exist (which is always the
  case since we do not yet support this, default to the BE version.
  If we do not do this, when we try to write a string, the UTF-16/32
  encoding will sometimes output a before encoding the string, which
  throws off the output. This means we will never actually use UTF-16/32
  encoding, we will always use either BE or LE versions, which do not
  ever encode a byte order mark.
- Additional schema changes to support round tripping, without changing
  the meaning of tests.

DFDL-1548

6 years agoSupport round tripping for sections 2-5
Steve Lawrence [Tue, 21 Jun 2016 23:43:54 +0000 (19:43 -0400)] 
Support round tripping for sections 2-5

- When unparsing longs, we need to mask off the high bits that are to be
  ignored. For example, say we are writing the value -3, which in two's
  complement binary is 0b11111..11101. If we only want to write 5 bits
  of that, we need to mask off those 5 bits, since later we binary-or
  the value, and we don't want those high bits to get in the way.
- In Rep.loopExactlyTotalN, we need to inspect the end of the array,
  just like we do in other rep unparsers. Otherwise, we could end up
  with extra occurrances/separators.
- Do not treat unparse validation errors as fatal errors.
- Changes to tests to make them roundtrippable, without changing the
  intention of the test. For some tests, roundTrip is just disabled.

DFDL-1547

6 years agoSupport unparsing choices inside hidden groups
Steve Lawrence [Tue, 21 Jun 2016 16:33:44 +0000 (12:33 -0400)] 
Support unparsing choices inside hidden groups

- The DFDL spec requires that everything inside a sequence either be
  defaultable or has outputValueCalc, otherwise it is an SDE. This adds
  those necessary checks.
- Related to the above, there must be a way to determine which branch
  should be taken when unparsing a choice inside a hidden group.
  Normally we choose the branch base on the infoset events that we see.
  But such infoset will not exist inside a hidden choice. So to
  determine which branch of a hidden choice to take, we unparse the
  branch this is entirely made up of defaultable or OVC elements. If
  there are more than one such branches, we report a warning and will
  unparse the first branch. If no such branches exist, then it is an
  SDE.
- When a choice is hidden, we can now statically determine exactly which
  branch to unparse at compile time. So create a new
  HiddenChoiceCombinatorUnparser, which only accepts that unparser as an
  argument, and just calls unparse on it.
- Modify many tests that used hidden choices or elements inside hidden
  groups that did not contain OVC so they would no longer SDE.

DFDL-1545

6 years agoSet the current infoset node in the StatementElementUnparserNoRep
Steve Lawrence [Thu, 16 Jun 2016 13:39:25 +0000 (09:39 -0400)] 
Set the current infoset node in the StatementElementUnparserNoRep

Even though these elements are inputValueCalc, we still need to set the
infoset node. This is for a couple of reasons:

1) The StatementElementUnparserBase asserts that it has an infoset. As a
   contrived example, imagine a schema in which the root is an
   inputValueCalc element. There will only ever be one infoset node, so
   the IVC unparseBegin/End must set it so this invariant passes. Note
   that although this example is contrived, it is used heavily in TDML
   tests, and is technically valid DFDL, so it should work.

2) Imagine an IVC element that sets a variable, and that setVariable
   expression references the value of the IVC element. In this case, the
   current info node does need to be set to the IVC infoset element so
   that the setVariable expression can access it with '.' or
   'self::foo'.

So, this modifies StatementElementUnparserNoRep to use the same
unparseBegin/End functions as StatementElementUnparser (i.e. do not
override them) so that the current infoset node is set to the IVC when
unparsing. Now the only difference between StatementElementUnparser and
NoRep, is move() override to avoid separators from being laid down.

This change enables about 150 extra tests to round trip.

DFDL-1543

6 years agoEnsure encodings are correct
Steve Lawrence [Tue, 14 Jun 2016 11:13:57 +0000 (07:13 -0400)] 
Ensure encodings are correct

- When determining when to insert an EncodingChangeParser/Unparser, we
  currently check to see if the current element has the same encoding as
  the previous sibling element. However, if the previous sibling element
  is a complex type and has children that change the encoding, it is
  possible that a child of the previous sibling will change the
  encoding, and then we'll end up using that encoding, which isn't
  correct. So instead, in addition to checking if the previous sibling
  has the same encoding, ensure that all the children have the same
  encoding as the previous sibling. If not, we will insert an
  EncodingChangeParser/Unparser, just in case a child changes it.

- Only change hexBinary to an iso8859-1 encoding if lengthKind is
  delimited. In all other cases, we just read a specified length number
  number of raw bytes and do not treat anything as a string. This
  prevents unnecessary EncodingChangeParsers to be inserted.
  Furthermore, because there are issues with other encodings (e.g
  multi-byte characters, non-byte-size encodings, etc.) restrict
  hexBinary to an encoding of ISO-8859-1.

DFDL-1521

6 years agoFix CLI test regressions
Steve Lawrence [Tue, 14 Jun 2016 21:13:25 +0000 (17:13 -0400)] 
Fix CLI test regressions

- New warning if dfdl:length is provided but dfdl:lengthKind is not
  explicit
- Change in parser outputs

6 years agoProgress toward dfdl:outputValueCalc and dfdl:contentLength function.
Mike Beckerle [Tue, 14 Jun 2016 11:27:20 +0000 (07:27 -0400)] 
Progress toward dfdl:outputValueCalc and dfdl:contentLength function.

Removed DISequence and DIChoice which are no longer needed.
Preserved code and test code for possible use in the future, for
experimental feature when dfdl:outputValueCalc or similar feature is
extended to allow computing complexType elements.

dfdl:valueLength - stubbed.

DataOutputStream - these now preserve the absolute bit pos information
(for use in alignment regions) as buffers are spun off. The length of an
OVC element is added in so that we have the correct absolute bit pos at
the start of a buffer.

Infoset modified to have places to store starting and ending bitPos
for every node. This can be used to compute contentLength in bits/bytes.

Infoset throws specific Infoset exceptions if a
request is made to get the contentLength or valueLength, and it has not
yet been computed. This is the mechanism by which OVC expressions can
block their evaluation to wait for this information to be created.

The DPath expression operations that access the infoset do so by way of
methods on the DState object. When in Blocking mode (for forward referencing
expressions) these implement a retry-loop if the infoset throws exceptions.
Coroutines are used to allow unparsing to continue while waiting for this
to be retried.

Modified Element parsers and unparsers to update the start and end bitPos
of infoset elements. All element combinators changed so that they get a
before, element, and after gram. So that the processing of the content
(without any framing) is easily isolated. That's where the contentLength
-in bits, is captured.

(Note: bug - there have to be separate contentLength slots for parsing
and unparsing. Otherwise when parsing something can have zero
contentLength, a default value gets created, and on unparsing it has a
non-zero content length. If we round-trip and unparse from a
parser-created infoset, then an OVC element that reaches forward to get
the contentLength will get the answer left there by the parser, rather
than the expression blocking for the unparser to fill in the
contentLength. We could introduce separate content length for use by
parser and unparser, or we can clear the content-length as infoset
events are processed. )

Split OVC grammar primitive into a static and runtime flavor.

(TODO: create a lengthInBits EV that depends (optionally) on the
LengthEv) Then this could be collapsed back into just one flavor.

SuspendableExpessions use Coroutines.

Alignment is not possible after a variable-length OVC element
(for now), because alignment suspensions are not yet implemented.

Updated some tests so they will pass stricter checking.

Added unit tests for some middle end attributes that are critical to
getting nextElementResolver right.

Several tests of forward-expressions calling dfdl:contentLength are in
daffodil-test section 23 dfdl-expressions, contentLength.tdml.

Ignore hiddenGroupRefs when calculating possible next/firstChild elements

Properly convert text date/times from XMLCursor to DFDLDateTimes

Disable round tripping text bigInteger. BigInteger doesn't work properly
on unparse. When the ICU number formatter formats a bigInt, it looses a
lot of precision. For example, this

     BigInt(686479766013060971498190079908139)

Formats to the string:

     "686,479,766,013,061,000,000,000,000,000,000"

Updates to PCAP to use outputValueCalc for ICMP packets, including
adding support for EchoRequest and EchoReply in ICMP PCAP messages

Make OVC elements optional in the infoset when unparsing.
- Modify the next element resolvers to treat OVC elements as optional
- Modify the OVC statement element combinator to optionally consume OVC
  element events if they exist

Fix unparsing recurrence indicators expressions for mil-std-2045

    Recurrence indicator expressions in mil-std-2045 look like this:

      dfdl:outputValueCalc="{ if (dfdl:occursIndex() lt fn:count(..)) then 1 else 0 }

    Two issues were fixed to support this:

    - dfdl:occursIndex() was always 1 due to the way we cloned UState for
      OVC. We also clone the dState, but upon expression evaluation, some
      dState values are overwritten with values in the UState. This is the
      case with arrayPos. So when cloning the UState, clone the stack that
      is used to set arrayPos in the dState upon expression evaluation.

    - The parent axis (..) only moves up to the parent, which is always
      going to be a complex type. However, used in the specific context of
      fn:count, we really want the parent axis to reference the actual
      array so we can get it's length. To support this, modify DPath so
      that if .. is the last step element, and that element is an array, and
      the target type of that path is an array, then use a different dpath
      recipe to access the array rather than the complex type. This also
      requires adding a new field to DIElements to store the array if they
      are in one.

6 years agoFixed compiler warning causing automated tests to fail.
Mike Beckerle [Thu, 2 Jun 2016 19:35:59 +0000 (15:35 -0400)] 
Fixed compiler warning causing automated tests to fail.

6 years agoSimplified pretty printer so it does nothing to simple types.
Mike Beckerle [Tue, 31 May 2016 21:31:07 +0000 (17:31 -0400)] 
Simplified pretty printer so it does nothing to simple types.

This pretty printer just indents two x nesting depth before element
starts, and for complex type elements, before element ends. Simple type
elements appear all on one line with nothing ever done to the
whitespace.

This eliminates a number of artifacts of pretty printing that were
making comparisons fragile, and bothering users who weren't expecting
the whitespace in simple elements to be manipulated.

Also eliminates redundant xmlns bindings.

6 years agoAdding example file for unparsing csv
Beth Finnegan [Mon, 30 May 2016 19:59:57 +0000 (15:59 -0400)] 
Adding example file for unparsing csv

6 years agoImprove USASCII 7-bit encoder and support unparsing
Steve Lawrence [Tue, 10 May 2016 20:50:08 +0000 (16:50 -0400)] 
Improve USASCII 7-bit encoder and support unparsing

- The previous implementation of the USASCII 7-bit encoder was simple,
  but fairly inefficient. This rewrites the encoder to use binary
  operators rather than scala sequence operators to improve the
  efficiency when encoding. Additionally, this checks for invalid
  characters (i.e. characters that do not fit in 7-bits) and properly
  checks for overflow/underflow.

- Modify putCharBuffer to support non byte sized encodings.

- Modify the non byte size encoder/decoder traits to separate the
  pieces specific to only encoding or decoding.

- Ensure that bitOrder is LSBF if the encoding is a non-byte-size
  character set

- Fix some places where bitOrder is used instead of defaultBitOrder

- Add new checkBitOrderAndCharsetEv to ensure that the bit order and
  character set match

DFDL-1499

6 years agoMade test_timeZoneFormats7 be roundTrip="false"
Mike Beckerle [Mon, 16 May 2016 20:18:49 +0000 (16:18 -0400)] 
Made test_timeZoneFormats7 be roundTrip="false"

Something is tripping up the central bamboo build, but it is not
reproducible on developer's machines.

This is an attempt to diagnose the issue. Clearly this test is not new,
but running it round trip is new.

6 years agoAdded LittleEndian Least and MostSignificantBitFirst.
Mike Beckerle [Thu, 12 May 2016 16:02:53 +0000 (12:02 -0400)] 
Added LittleEndian Least and MostSignificantBitFirst.
For longs, float and double. Not yet bigint/bigdecimal.

More tests set to round trip to provide coverage.

LengthProperties.tdml now round trips all tests by default.
Aligned_Data.tdml now defaults all tests to roundTrip.

Improved TDML Runner round trip and comparison logic for unparse test.
(Was creating big megabyte buffers. IOUtils.toByteArray(is) to the
rescue.)

Revert whitespace and line wrap changes that crept in to SimpleTypes.tdml.
Per review.

6 years agoDataOutputStream putLong implementation and unit tests
Mike Beckerle [Fri, 6 May 2016 23:00:58 +0000 (19:00 -0400)] 
DataOutputStream putLong implementation and unit tests
which put to a DirectDOS and BufferingDOS work for BigEndian,
MostSignificantBitFirst.

Fixed TDML Runner to check return status from round-trip unparser calls.

Implemented BinaryIntegerKnownLengthUnparser and related.

Enhanced TDML runner to allow defaultRoundTrip attribute on the testSuite
element so one can make a whole suite default to round-trip.

The roundTrip flag only applies to success-expected parser and unparser
test cases.

TestSimpleTypes.scala set to round trip all tests by default.

BigEndian MostSignificantBitFirst putLong and unparsing works.

Split TestSimpleTypes.scala file into two parts that match the TDML
files. TestSimpleTypes.scala exclusively the tests in SimpleTypes.tdml
now.

Most TestSimpleTypes.scala tests (all but 44 of 299) were made
roundTrip. 44 were not.

These 5 tests parse, but do not unparse (round trip) due to lack of
bigDecimal/bigInt binary unparser support.

test_nonNegativeInteger_bin(edu.illinois.ncsa.daffodil.section05.simple_types.TestSimpleTypes)
test_integer_binary_02(edu.illinois.ncsa.daffodil.section05.simple_types.TestSimpleTypes)
test_decimal_binary_06(edu.illinois.ncsa.daffodil.section05.simple_types.TestSimpleTypes)
test_nonNegativeInteger_bin3(edu.illinois.ncsa.daffodil.section05.simple_types.TestSimpleTypes)
test_integer_binary(edu.illinois.ncsa.daffodil.section05.simple_types.TestSimpleTypes)

39 other tests do not round trip due to various bugs in date/time
unparsing, etc. This is not a regression. They weren't being run
round-trip before, and still do not work round trip so their TDML
parserTestCase elements have been modified with roundTrip="false".

The tests in SimpleTypes.tdml all pass because roundTrip="false" was
added to the tests that don't pass when round tripped.

6 years agoCleanup leaked threads
Steve Lawrence [Mon, 9 May 2016 19:19:23 +0000 (15:19 -0400)] 
Cleanup leaked threads

- In InfosetCursforFromXMLEventCursor, we were not properly detecting
  the end event for the root element if the last child was an array. In
  this case we would properly end the array and root element, but we
  would not return immediately. This meant that the Producer would
  continue to produce events when it shouldn't. Even if there is extra
  data past in the XMLEventCursor, we should end the InfosetCursor.

- Add fini method to Cursors, allowing the ability to cleanup a cursor
  if necessary. This is needed so that cursors that use coroutines can
  interrupt the producer threads and cause them to abort. For example,
  if the InfosetCursorFromXMLEventCursor completes due to finding the
  root end event, it's possible the XMLCursor could still be parsing
  data if there was more data following the end tag. This allows the
  InfosetCursorFromXMLEventCursor to force the XMLEventCursor to
  shutdown and clean up leaking threads.

- Add a final consumer unparser to the end of unparsing. After the
  consumer has consumed the very last end event, it needs to let the
  producer know that the event was consumed by doing on elast final
  advance. This allows the producer coroutine to continue processing and
  shutdown appropriately.

- When an expected exception is thrown in the producer (usually do to
  invalid XML), the consumer coroutine needs to rethrow them so that
  that can be caught by the main thread and convert it into an
  UnparseError.

- Remove a finally block during unparse(). If something fails there, it
  could potentially mask a real error.

DFDL-1497

6 years agoImprove performance of Evaluatables
Steve Lawrence [Fri, 6 May 2016 13:38:53 +0000 (09:38 -0400)] 
Improve performance of Evaluatables

Two changes were necessary to fix a performance degradation added in
9fb67399ab.

- In the majority of cases, caching evaluatable results actually causes
  a performance hit. This is likely due to the memory overhead of
  allocating the EvalCache hash maps and general hashing related
  overhead. There's actually less overhead to just reevaluate the
  expressions (which is pretty efficient with our custom XPath
  implementation). The only cases where we absolutely need to do some
  kind of caching are with EscapeSchemes (see 608f46b) and when the
  element is an outputValueCalc element. So for all current Evalutables
  except EscapeSchemeEv and those on an OVC element, disable caching.

- Do not compile Evaluatables during evaluation. Always require a direct
  call to compile() first. The problem here is with the synchronized
  block that allows compilation at runtime. This shouldn't even be
  necessary, and nothing was even hitting it during tests, but it still
  caused a pretty drastic performance penalty. So just remove this block
  Instead, let's just assert that Evaluatables must be compiled before
  trying to evaluate them and fix the Evaluatables so that is the case.
  And since we can assert that things are compiled before calling
  evaluate, there's no need to worry about setting constValue_ in the
  apply method. It's all handled by the overloaded compile method.

With PCAP, these changes saw about a 50% performance increase, and is
now actually about 8% faster than before Evaluatables were added.

DFDL-1484

6 years agoPut back encoder and decoder cache on the PState/UState.
Mike Beckerle [Wed, 4 May 2016 14:12:10 +0000 (10:12 -0400)] 
Put back encoder and decoder cache on the PState/UState.

Fixes non-thread-safe encoderEv and decoderEv.

DFDL-1495

6 years agoEnsure all marks are discarded, even if exceptions are thrown
Steve Lawrence [Tue, 3 May 2016 19:30:05 +0000 (15:30 -0400)] 
Ensure all marks are discarded, even if exceptions are thrown

If an unexpected exception was thrown sometime during parse, it could
result in not resetting/discarding marks. The exception would eventually
bubble up to the top, but before it got to the very top, we would check
to make sure everything in the mark pool was cleared. Because of the
exception, it was possible the mark pool wasn't cleared, so we would
immediately abort with an invariant, thus masking the original exception
that caused the problem. This makes it very difficult to debug
unexpected exceptions.

This changes Daffodil so that at the very top in doParse, we only
validate the final state if no unexpected exceptions are thrown. If we
see any unexpected exceptions, we immediately throw them, and skip
validation.

Additionally, remove a catch of generic Exception in the
OccursCountKindExpression parser. We should never be catching an generic
exception without rethrowing.

Also, avoid complex processing in a finally block in parse(). If
something fails in the finally blow and throws an exception, it will
mask the original exception (if one was thrown in the catch).

DFDL-1483

6 years agoEstablish the asymetry between DataInputStream and DataOutputStream
Mike Beckerle [Wed, 6 Apr 2016 18:39:01 +0000 (14:39 -0400)] 
Establish the asymetry between DataInputStream and DataOutputStream

The primary contribution of this commit is to establish the asymetry
between DataInputStream and DataOutputStream with respect to the
positions and limits in the bit stream.

For the DataInputStream, we have this concept of the current bitPos0b,
and optionally there may be abound called bitLimit0b. There are 1b
variants of these.

For parsing, these are always absolute values, that is they contain bit
position relative the ultimate start of the input stream where parsing
began.

For DataOutputStream, we have slighly different concepts.

There are absolute and relative variants. The absolute bitPosOb or
absBitPos0b is symmetric to the parser's bitPos0b. It's the position
relative to the ultimate start of the output stream.

However, we often do not know this value. So the UState and
DataOutputStream have a maybeAbsBitPos0b which can be MaybeULong.Nope if
the value isn't known.

In addition we have the relative or relBitPos0b. This is relative to the
start of whatever buffer we are doing unparsing into.

When unparsing, we often have to unparse into a buffer where the
ultimate actual absolute position isn't yet known, but we have to do the
unparsing anyway, for example so that we can measure exactly how long
something is.

Conversely, sometimes we simply must have the absolute output bit
position, for example, when computing the number of bits to insert to
achieve the required alignment.

Hence we have relBitPos0b - always known and is a value >= 0, and we
have maybeAbsBitPos0b which is a MaybeULong. If known it is >=0.

Corresponding to bit position we have bit limit, which is measured in
the same 0b or 1b units, but is *always* a maybe type, because even in
the case where we know the absolute position, we still may or may not
have any limit in place. Hence the UState and DataOutputStream have a

maybeRelBitLimit0b
and
maybeAbsBitLimit0b.

One invariant is this: when the absolute bit pos is known, then it is
the same as the relative bit pos. Similarly when the absolute bit limit
is known, then the relative bit limit is known and is equal.

All deprecation warnings fixed.

No warnings now. Turned back on -Xfatal-warnings in scala compile
options.

There is still CachedDynamic in here, which is now using Evaluatable, so
we have the caches on top of the caches still.

Added missing maybeAbsBitPos0b and 1b methods.

6 years agoThe test for DFDL-930 passes already. This contains
Taylor Wise [Fri, 29 Apr 2016 15:27:02 +0000 (11:27 -0400)] 
The test for DFDL-930 passes already. This contains
the fix for DFDL-929.

The issue came from two problems:
1. That we were returning within the
parameter of a function (ExecutionMode).  This caused
a NonLocalReturnControl to be thrown.

Unfortunately the NonLocalReturnControl error contains
no stack trace.  So there was no obvious way to trace
its origin.

2. The expected infoset element name was incorrect in
the TDML document.  This was made apparent once we
were able to force the stack trace using the Scala
system property: scala.control.noTraceSuppression=false.

The lesson learned here is that we should avoid use of
the return statement as it is:
1. Hard to find the source.
2. Hides the real errors.

DFDL-930, DFDL-929

6 years agoRefactor delimiter scanning to improve performance
Steve Lawrence [Thu, 7 Apr 2016 12:24:11 +0000 (08:24 -0400)] 
Refactor delimiter scanning to improve performance

- In addition to using a delimiter stack combinator if a term has
  delimiters, we also need to do it if it doesn't have delimiters but
  its enclosing term does. This is because we need to bump the local
  index stack so that the local delimiters become remote. This way,
  matching a delimiters in a scope where there are no delimiters forces
  backtracking.

- Instead of using the delimiter stack nodes, all delimiters are now
  appended to a single "delimiters" array when they come into scope. An
  int stack maintains an index of which of those delimiters are local vs
  remote for the current scope. When a DFADelimiter is added to the
  delimiters array, its index in the array is stored so we can very
  quickly determine if a delimiter is local or remote. Custom iterators
  are added to loop over the delimiters array only looking at the
  delimiters that one cares about. This way, we are not creating
  multiple lists (via flatmap, filter, etc.), which had a huge
  performance impact. Note that this doesn't change the unparsing
  delimiter stack nodes. Unparsing changes are made only to use the new
  iterators, but there is still alot of duplicate list creation that can
  probably go away. However, unparsing works slightly differently than
  parsing, and potentially needs a different design.

- Add type and location information to DFAdelimiters. Now that they are
  all in one array, rather than in different variables for types, we
  lose type information. This means anything that creates a dfa now
  accepts a type and runtime data for location information. This also
  makes the code quite a bit cleaner so we don't have to carry around
  Tuple2(String,String) all over the place for location information.
  This allows allows for more precise location information by using
  SchemaFileLoctable.

- When storing a found delimiter, store the dfa ParseResult rather than
  the FoundDelimiter. That just adds an extra allocation, and the
  ParseResult contains everything we need.

- Improve the use of found delimiter. We were actually clearing this way
  too often, which resulted in rescanning for delimiters that we had
  already found. Now, anytime we find a delimiter, we will never rescan
  for it, we'll either end up using it, or throw an error if it wasn't
  the correct delimiter. Related, we now keep a list of multiple found
  delimiters. Since we no longer aggressively clear delims, it's possible
  that multiple DFAs matched a single delim. For example, if a separator
  and terminator are the same, then, which these changes, two DFAs are
  matched. So we now hold on to all DFAs that match, and use those for
  determining when to stop backtracking.

- Removes the longest match function and replaces it with a longest
  match tracker. Before we would make a list of all successful matches,
  then we would filter the list down to just the longest match. Instead,
  keep track of the longest matches (it can be multiple now) as
  successes are found so we aren't creating multiple array buffers.

- Large refactoring of DelimiterTextParser to take advantage of the new
  delimiter array.

- Reduce the amount of information when creating ParseErrors when a
  remote delimiter was found (like what where delimiters came from, what
  text was found when a delimiter wasn't found, etc.) It was actually a
  non-trivial amount of computation/allocation to figure out all that
  was displayed. Plus, it is very normal behavior to backtrack due to
  finding a remote delimiter. So, lets make the common case fast, and if
  someone needs more information, they can drop into a debugger. Or we
  can add it back later if it's really necessary.

- When unparsing and determining what to escape, we need to look at all
  terminating markup, not just the in scope delimiters. All terminating
  markup needs to be escaped.

- Add new debugger commands (delimiterStack and foundDelimiter) to show
  delimiter information. This comes in very useful when things go off
  the rails.

- Do not pass the kind string to DelmiterTextParser. We can use the
  delimiterType to figure out the kind string.

- In Main.scala, set the debugger after enabling it. If the proc is a
  tdml runner, enabling debugging automatically sets the debugger to
  trace even if you want it to be interactive. By doing it in this
  order, it allows you to run 'daffodil -d test foo.tdml' and get the
  interactive debugger while running a tdml test

- Add a prefixedName function to RuntimeData. In some places, we would
  try to print a prefix (e.g. ex:foo), but there wasn't a prefix and
  we'd get a null string (e.g. null:foo).

With these changes, text delimited parser performance increases by about
50-70%.

DFDL-1285

6 years agoChange Field DFA to use Evaluatables
Steve Lawrence [Fri, 15 Apr 2016 13:08:22 +0000 (09:08 -0400)] 
Change Field DFA to use Evaluatables

This removes alot of the factories associated with DFA parsing,
including the field dfa factories and the text parser factories. This
simplies the code quite a bit, and creates a consistent 5% increase with
the simple CSV example. This is a nessary first step to improving the
maintainability and performance of delimiter scanning.

Specific changes include:
- Removes the need to have the escape scheme, current parser, and
  fieldDFA stored in mutable state. Simplifies MState and reduces amount
  of memory that needs to be copied when marking the state.
- Makes caching mechanism in Evaluatable's pluggable. This is necesary
  to allow for different caching mechanism. A new mechanism is added
  that caches the value in a stack in pstate and requires the
  'owners' of the Evaluatable to reset the cache when necessary. This is
  used for the escape scheme evaluatable. This allows us toRather than evaluating and
  storing it on the mstate, we can instead evaluate it at the
  appropriate time, have the value cached in the Evaluatable, and any
  other things that use that will get the cached version. Simplifies
  things quite a bit.
- Removes the need to also have an EscapeSchemeParser. It is only
  necessary when there are dynamic escape schemes to ensure escape
  schemes are evaluated at the right point.

DFDL-1488

6 years agoUse Evaluatables for escape scheme and related properties
Steve Lawrence [Fri, 8 Apr 2016 13:11:11 +0000 (09:11 -0400)] 
Use Evaluatables for escape scheme and related properties

- Replaces the EscapeSchemeObject (which held parameters for both block
  and escape scheme) with Evaluatabes specific to Char or Block. This
  means that fields that used to be optional are now mandatory, since we
  only access the fields if we need them. So a handful of Maybe/Options
  go away, simplifying the code a bit. This also allows us to remove the
  EscapeScheme{Static,Dynamic}Factory code, which was complicated and
  contained a good deal of duplicated and deprecated (i.e.
  CachedDyanmic) code.
- Change EvaluatableExpression to accept a RuntimeData rather than only
  TermRuntimeData. The escape scheme evaluatables are created using the
  runtime data of the DFDLEscapeScheme, which is not a Term.

DFDL-1487

6 years agoUpdate sbt to use scala 2.11.8
Steve Lawrence [Thu, 21 Apr 2016 18:42:59 +0000 (14:42 -0400)] 
Update sbt to use scala 2.11.8

A bug [1] in scala 2.11.7 related to the -Ybackend:GenBCode option
causes sbt to not recompile class files when generating a jar after a
clean. This bug has since been fixed in scala 2.11.8 [2]. This patch
upgrades the sbt configuration of daffodil to use scala 2.11.8 so that
we can properly clean and rebuild within the sbt console.

Additionally, scala 2.11.8 seems to have improved its unused import
detection causing hundreds of warings. This patch  removes those many
unused imports.

[1] https://github.com/sbt/sbt/issues/2076
[2] https://github.com/scala/scala/pull/4588

DFDL-1491

6 years agoMoving extraEscapeCharacter tests from new to scala
Beth Finnegan [Thu, 28 Apr 2016 21:52:33 +0000 (17:52 -0400)] 
Moving extraEscapeCharacter tests from new to scala

DFDL-261

6 years agoFixes issue where unparser tests that
Taylor Wise [Wed, 13 Apr 2016 18:30:51 +0000 (14:30 -0400)] 
Fixes issue where unparser tests that
expect SDEs were failing.

Runtime code on unparser side was missing
some case statements to handle SDEs.

Essentially, prior to the fix for DFDL-261
these SDEs were not being caught and were
simply bubbling up.  Unfortunately, now that
we have added the missing cases, we can no
longer use the 'interecept' code to catch
the exceptions.  Exceptions now end up
in a diagnostics list, which then ends up
being rethrown as a new Exception.  This
would cause the intercept code to fail
because it expected SuspendedExpressionsDeadlockException
but got java.lang.Exception.

For the failing test, testoutputValueCalcDeadlock,
we use a try-catch instead of the intercept command.
This corrects the issue.

Moved ProcessingError out of ParseErrors file into
its own file so that UnparseErrors can refer to it.

DFDL-1489

6 years agoThis feature was already implemented.
Taylor Wise [Wed, 13 Apr 2016 18:11:32 +0000 (14:11 -0400)] 
This feature was already implemented.

Added basic tests to verify that this
feature is working as expected.

While creating these tests, encountered
a bug in the Runtime code.  Tests expecting
errors on the unparse side were not working.
Created DFDL-1489.

DFDL-261

6 years agoAdding test for replacing delimiters with Evaluatables
Beth Finnegan [Tue, 12 Apr 2016 18:54:33 +0000 (14:54 -0400)] 
Adding test for replacing delimiters with Evaluatables

DFDL-1485

6 years agoImplements entities for nilValue LiteralCharacter.
Taylor Wise [Wed, 30 Mar 2016 18:54:17 +0000 (14:54 -0400)] 
Implements entities for nilValue LiteralCharacter.

Adds some basic tests.

Refactor LiteralNilParsers.  Adds a base class.

Adds an additional test to check bytes.

Adds additional tests for both parse and unparse
to verify the appropriate entities are allowed
or disallowed.

DFDL-260

6 years agoUse Evaluatables for delimiters
Steve Lawrence [Mon, 4 Apr 2016 12:47:11 +0000 (08:47 -0400)] 
Use Evaluatables for delimiters

- Create new Evaluatbles for initiators, separators, and terminators.
  Different Evaluatables are created for both parse and unparse due to
  the unparse dependency on outputNewLine, which parse does not have
- Remove deprecated initiator, separator, and terminator vals
- Remove the compiled expression from DelimiterText parsers. This hasn't
  been used since the delimiter stack was implemented
- Remove allTerminatingMarkup and functions/tests that use it. These
  functions are old and have not been used since the delimiter stack was
  implemented
- Move runtimeDependencies from PrimProcessor to Processor. The
  DelimiterStackNode processors are examples of non-primitive processors
  that have runtime dependencies, so the restriction that only
  primitives can have runtime dependencies is unnecessary.
- Change Processor initialization to walk the processor tree, rather
  than creating a list of all processors, and ensuring the dependencies
  are compiled. This should only happen once, so there's no need to save
  the list of processors. Plus, the list of processors is large (and
  would take up n^2 space) and never used at runtime, so it's a bit of a
  waste of memory.
- Remove dead reflection code in allRuntimeDependencies that tried to
  determine runtime dependencies without having to manually specify
  them. It was overly complex, error prone, and it seemed to slow
  compliation down some.

DFDL-1485

6 years agoAdding tests for calendarLanguage at runtime.
Beth Finnegan [Fri, 25 Mar 2016 15:16:35 +0000 (11:16 -0400)] 
Adding tests for calendarLanguage at runtime.

DFDL-927

6 years agoEvs are obtained by runtimeDependencies lists that are maintained
Mike Beckerle [Fri, 11 Mar 2016 22:03:48 +0000 (17:03 -0500)] 
Evs are obtained by runtimeDependencies lists that are maintained
manually, but are checked and if all the Evs are not initialized before
runtime an error is issued.

DFDL-1271

6 years agoOutputNewLine converted to "Ev" idiom.
Mike Beckerle [Thu, 10 Mar 2016 19:23:57 +0000 (14:23 -0500)] 
OutputNewLine converted to "Ev" idiom.

Deprecation warnings added to values associated with the old way of
doing things. This results in 66 warnings that I'm not planning to fix
in this commit, hence, I've changed the build.sbt to tolerate warnings
temporarily.

Charsets are standardized by cooker to uppercase trimmed.

And other changes per code review. With the exception of the conversion
of runtimeDependencies manually maintained to an automated
reflection-based approach. This will be investigated separately.

DFDL-1271

6 years agoAdded Evaluatable[T], EvalCache, and DISequence, DIChoice.
Mike Beckerle [Wed, 17 Feb 2016 02:39:39 +0000 (21:39 -0500)] 
Added Evaluatable[T], EvalCache, and DISequence, DIChoice.

DITerm mixin provides evalCache member to DIElement and DIModelGroup.

Added toXML inclusion of format info in an XML Processing Instruction.

A ProcInstr should be ignored by applications that receive the XML so in
principle we could leave it in and not disturb consuming applications.

However, there is still overhead to create this PI and so it is
not created by default.

Note: CLI tests will fail if the feature is enabled that
displays the EvalCache as a Processing Instruction in the XML Infoset.

First unit tests that display information about the sequence groups
within a DIComplex infoset item are working.

Converted everything from using Any to AnyRef.

This should eliminate much boxing/unboxing. The Infoset, expressions,
etc. all carry java.lang.Number subtypes, not AnyVal numeric types.

Some of the code base uses java.math.BigInteger and
java.math.BigDecimal. Other parts use scala's BigInt and BigDecimal.

The former are slightly less overhead, the latter have much easier
arithmetic expressions (you can use ordinary +, -, *, /, mod, div, etc.

They're interconvertable, so this is ok. But it would be good to
standardize.

Note that scala BigInt isA java.lang.Number - it is derived from
ScalaNumber which is derived from java.lang.Number. Similarly for scala
BigDecimal. So getting all the polymorphic numbers to be
java.lang.Number doesn't require going back to java.math numbers.

This also fixed some bugs where conversions were insisting things were
no bigger than a Long.

Expression evaluation now works via methods of Evaluatable.

Changes to XML comparison routines to enable comparisons to still
succeed even with our XML ProcInstr <?formatInfo ... ?> in the XML
infoset.

Property dfdl:calendarLanguage implemented using new Evaluatable.

Added test case that uses runtime-valued dfdl:calendarLanguage (parsing)

Silenced noise coming out of many tests.

Makes test output easier to read.

New Entities replacer organization.

Shares same entity inspection/replacement code everywhere instead of
having different checks for static and different for dynamnic.

This does not yet go so far as to collapse the separate dynamic/static
pathways, but at least they're all calling the same Entity "cooking"
routines.

The goal is, however, to collapse the separate static/dynamic code
pathways, at least for the unparser at first, and eventually for the
parser as well. To extent that they are sharing the code that evaluates
properties it will get refactored for both.

Parked an identifiable bug DFDL-1473 because I found many property error
messages not being created because validation wasn't happening. This is
a quick fix, but don't want all those test cases to break because the
message output changes. So parked that for a later commit.

Delimiter bug fixed in "%%" situations.

Delimiter expressions with "%%" in them were removing the %% to % before
processing the delimiter strings for presence of char class entities.
But this is wrong since it woudl change "%%WSP+;" into a matching char
class entity.

Removal of %% has to be done late/last. Basically at the point where the
char class entities are being converted into objects.

Filed DFDL-1475 about bad diagnostic message if a terminator is
runtime-value, but happens to return say "%ES; ," which because ES is
alone, is not allowed.

Revised Evaluatable and reimplemented calendarLanguage.

test_unparseRuntimeCalendarLanguageOVC

This test has an outputValueCalc element with a forward reference to a
string. The ovc element is a xs:date, which uses the
dfdl:calendarLanguage property which is runtime evaluated. It is cached
on the infoset element of the date element.

Bit order and byte order changes use Evaluatable.

The checking code for compatibility of bit and byte order settings
exists in only one place now. If byte order is a runtime-valued
expression then this check will be evaluated at runtime also..

Also fixes DFDL-1468 about bitOrder and byteOrder being coupled when in
fact bitOrder and byteOrder can be orthogonal, and byteOrder doesn't
apply to model groups but bitOrder does (because it can affect
characters in text strings if they are less than a byte in size.

Added test that shows runtime cache works.

Also Unparsing for text xs:date works.

Expanded the set of properties supported with Evaluatables.

Removed Encoder/Decoder caching from PState/UState because it's just
silly. Most formats are not going to change encodings much. If they do
allocating a decoder/encoder is no big deal.

Fixing Debugger interactions with new throws from Infoset. These changes to make the Infoset more flexible create lots of situations where expression evaluation has to consider what may be thrown.

DFDL-1471, DFDL-927, DFDL-1271, Unparser

6 years agoFix to remove TypeConversions object. v1.2.0-alpha.1
Mike Beckerle [Tue, 16 Feb 2016 19:26:22 +0000 (14:26 -0500)] 
Fix to remove TypeConversions object.

Also fixed typographical errors in messages, added some block comments
that were missing but needed.

Improved diagnostics from throws.

Fixed bug where property names were being case-insenstive compared.

Removed a number of block comments, and whole files that were fully
commented out, as these specific ones were unlikely to get used in the
future, and/or were just creating confusion.

DFDL-1469

6 years agoRename tutorial tdml to have ".xml" extension.
Mike Beckerle [Tue, 9 Feb 2016 20:22:16 +0000 (15:22 -0500)] 
Rename tutorial tdml to have ".xml" extension.

The tutorial files are going to want to be served from web servers we
don't control and can't customize. Mostly these set the MIME type of the
data based on the file extension, and they won't know what ".tdml" is so
it will come through as type text, and won't get XSL transformed.

If we use ".xml" extension on the end, then such servers will get the
MIME type right and all will work.

So tutorial files naming convention is topic.tutorial.tdml.xml

6 years agoFixed tests in tutorials so they actually run.
Mike Beckerle [Fri, 5 Feb 2016 17:29:33 +0000 (12:29 -0500)] 
Fixed tests in tutorials so they actually run.

6 years agoAdded support for X-DFDL-US-ASCII-7-BIT-PACKED name.
Mike Beckerle [Wed, 27 Jan 2016 17:00:01 +0000 (12:00 -0500)] 
Added support for X-DFDL-US-ASCII-7-BIT-PACKED name.

The older name, which lacks the "X-DFDL-" prefix is still accepted as an
alias, but a warning is issued.

(Motivated by bit-order tutorial authoring. Which uses this encoding. We
want the tutorial to use the official name, and be runnable.)

DFDL-1467

6 years agoFixed macro to remove need for redundant self argument.
Mike Beckerle [Mon, 25 Jan 2016 22:05:11 +0000 (17:05 -0500)] 
Fixed macro to remove need for redundant self argument.

Made all macros hygenic - they all generate val names using c.freshName.

DFDL-1466

6 years agoFirst tests of outputValueCalc with real forward referencng working.
Mike Beckerle [Wed, 23 Dec 2015 06:19:16 +0000 (01:19 -0500)] 
First tests of outputValueCalc with real forward referencng working.

No regressions.

LayeredDataOutputStream, BufferedDataOutputStream, withBitLengthLimit

macro for withBitLengthLimit

ParseOrUnparseState.dState(expr) so every expression can have a DState
for unparsing.

SuspendableExpression - first cut

Revised BufferedDataOutputStream.

Eliminated LayeredDataOutputStream. Simplified "collapsing".
Renamed to reflect direct or buffered state.
Added unit tests.
Removed queue. Any BufferedDataOutputStream can give rise to only one
other new BufferedDataOutputStream.

Dynamic.scala - added a diatribe on why this complexity needs to
refactor/evolve into something cleaner and more minimal. This is only
used by text numbers, not universally. I'm not even sure these "caches"
are ever hit twice. It's less a cache than a runtime call to a converter
that can be converted at compilation time in the static case. (If so
rename at minimum)

Refactor and Simplify DataOutputStream.

For parallel structure, refactored DataInputStream also.

First OVC unit tests with real forward referencing working.

6 years agoRemoved all methods from Maybe[T] that pass functions.
Mike Beckerle [Wed, 20 Jan 2016 17:39:09 +0000 (12:39 -0500)] 
Removed all methods from Maybe[T] that pass functions.

These allocate function objects. Better to avoid these and write the
simple if-then-else than use this allocating stuff.

Also removed map from MaybeFloat.
MaybeInt and MaybeULong didn't need changes.

Updated all usage.

6 years agoXML Schema for TDML modified to accept tdml:tutorial elements.
Mike Beckerle [Thu, 7 Jan 2016 15:18:21 +0000 (10:18 -0500)] 
XML Schema for TDML modified to accept tdml:tutorial elements.

Added test/example of a TDML-based tutorial. Enhanced XSLT to work for
unparse cases, and to put some boilerplate down.

Added a CSS stylesheet (derived from the one for tresys.com) which is
way overkill and confusing for something as simple as this.

Added unit test to TDML module that tests that all the various tutorial
element locations are tolerated by the validation of the .tdml file by
the TDMLRunner. This also shows that the TDML can be run as usual.

Created tutorials module.

only a test module and the beginnings of the bitorder tutorial are there
but the structure is there for more.

Review changes, and other improvements.

Removed noise from CSS.
Improved output of XSLT.
Touched up bitorder example file (e.g., took out negative tests).
Wrapped text lines that were super long.

Review-driven improvements. Removed math.xsd, svg.xsd, and xhtml5.xsd.

Added feature where tutorials can suppress certain objects in the TDML
file so they won't appear. You add a tdml:tutorialInclude='no' to any
child element of a defineSchema or the defineSchema itself, or to a
infoset or document, and it will be suppressed.

Fixed a unit test to use more ordinary prefix conventions in tdml for
the infoset.

6 years agoRevised VariableMap to be more abstract.
Mike Beckerle [Thu, 24 Dec 2015 00:43:51 +0000 (19:43 -0500)] 
Revised VariableMap to be more abstract.

Uses VariableRuntimeData now as the primary way to index into a map.

For debug purposes, you can still use a globalQName to index in. Since
that's what unit tests have around more easily.

This implementation could now be changed into one that is a mutable part
of pstate/ustate, and we could eliminate the hash-table/map and all the
allocation and cost and replace it with an array where a variable VRD
provides a slot number for use at runtime.

Note that backtracking must unwind variable state changes.

6 years agoAdded NonAllocatingMap class.
Mike Beckerle [Tue, 22 Dec 2015 23:46:09 +0000 (18:46 -0500)] 
Added NonAllocatingMap class.

Encapsulates a java map, and uses Maybe[T] to avoid allocation of an
Option[T] for a successful get(key) call.

6 years agoRemove mandatory marking in StatementElementCombinator
Steve Lawrence [Tue, 12 Jan 2016 19:40:20 +0000 (14:40 -0500)] 
Remove mandatory marking in StatementElementCombinator

StatementElementCombinator currently marks at the beginning of the parse
function, regardless of if it is actually necessary or not. And it is
only actually necessary if there are pattern discriminators or
assertions. If those do not exists, then we never need to save the state
in this parser. Refactor the code so that marks are avoided when
possible.

This also discovered a bug in which discarding a PState.Makr did not
properly discard the associated data input stream mark.

Additionally, change some Option[Parser]s and Array[Parser]s with
size 1 to Maybe[Parser]s.

Initial testing saw a 20-25% increase in performance.

DFDL-1465

6 years agoReduce allocations of complex state
Steve Lawrence [Wed, 6 Jan 2016 19:33:44 +0000 (14:33 -0500)] 
Reduce allocations of complex state

When saving DIComplex state, rather than allocating a new array the same
size as the number of slots and setting flags in that array, we can
instead just keep track of the last slot that was updated (and if it was
an array, how big it was). This is all the information necessary to
backtrack properly. Note that this will not work with unordered
sequences. For that, we will need a new DIComplex type that does record
all the necessary state, but we can implement that when unordered
sequences are reenabled.

On various tests, these changes saw about a 10% increase in performance

DFDL-1464

6 years agoReduce tuple and function allocations
Steve Lawrence [Tue, 5 Jan 2016 16:57:28 +0000 (11:57 -0500)] 
Reduce tuple and function allocations

- The USASCII7BitPackedDecoder used a tuple4 match and closures to
  decode characters. This results in a large amount of allocations, so
  refactor the code to use if-then-else logic and no closures.
- Remove a case of tuple3 allocations in the equality comparison code

DFDL-1461

6 years agoRe-enable asserts removed in 7df3b8e1
Steve Lawrence [Mon, 4 Jan 2016 15:01:15 +0000 (10:01 -0500)] 
Re-enable asserts removed in 7df3b8e1

Assertions in critical sections were removed due to the overhead
involved with allocating anonymous functions. Commit 222b35afc4b
introduced macros for the assertion functions, which prevents this
unnecessary allocations. Add these assertions back with no noticeable
overhead.

DFDL-1459

6 years agoCorrects getFieldDFA methods to remove tuple allocations per
Taylor Wise [Thu, 17 Dec 2015 19:27:26 +0000 (14:27 -0500)] 
Corrects getFieldDFA methods to remove tuple allocations per
parsed field.

Updates associated calls to just access and use the values
now present in the MPState.

getFieldDFA no longer returns 'state'.

Since mpstate is mutable, we no longer need to
return the 'state' from the getFieldDFA and
associated calls.

Removes 'unused' imports because of compile
errors when using sbt to run tests.

DFDL-1436

6 years agoMemory allocation removals
Steve Lawrence [Sat, 7 Nov 2015 18:22:28 +0000 (13:22 -0500)] 
Memory allocation removals

- Remove some Tuple2 allocations in IO layer and ElementKindParser
- Replace all instances of comparing PState.status with Success to be
  reference equality. Makes a slight difference in hotspot code like seq
  parsers that check this alot
- Remove nested clean function in element combinator. This caused the
  creation of many ObjectRef's. Not sure this made a huge different in
  terms of performance, but it definitely makes allocation profiling
  cleaner

These changes saw a small, but consistent, performance improvement of
3-5% when tested with PCAP with variables removed.

DFDL-1453

6 years agoRefactor binary number parsers
Steve Lawrence [Mon, 4 Jan 2016 14:02:01 +0000 (09:02 -0500)] 
Refactor binary number parsers

- Get rid of the reliance on BigInt using the new IO layer
- Change getSignedBigInt and getUnsignedBigInt to not return a Maybe,
  making it consistent with other I/O functions that get binary numbers.
  They now always return a value and throw an exception if a number
  could not be decoded
- Fix bug in I/O float/double functions that essentially moved the data
  position twice so the bit pos would be twice as far away as it should
- Simplify the binary number parsers, removing unnecessary calculations
  like byte order that slowed things down.
- Add support for dfdl:decimalSigned property
- Change error messages to be more consistent with other parsers

This change saw about a 15% increase in performance on PCAP examples

DFDL-1439

6 years agoLineCounter excludes a couple more giant TDML files.
Mike Beckerle [Tue, 22 Dec 2015 20:41:02 +0000 (15:41 -0500)] 
LineCounter excludes a couple more giant TDML files.

These are mostly just data, so shouldn't be counted.

6 years agoUpdate LineCounter to include more things, exclude more finely.
Mike Beckerle [Tue, 22 Dec 2015 20:06:23 +0000 (15:06 -0500)] 
Update LineCounter to include more things, exclude more finely.

Counts code, unit tests (scala code), tdml tests, DFDL schemas, and
demo code.

Excludes files authored by 3rd parties, TDML files that are mostly data.

Here's the summary output:

daffodil source total = 65134
daffodil unit test total = 26331
daffodil tests and examples total = 160113
DFDLSchemas total = 1689
daffodil-fouo/data-formats total = 27856
calabash total = 2779
all sbt files total = 489
Grand total = 284391 in 1108 files.

6 years agoImprovements per review.
Mike Beckerle [Fri, 18 Dec 2015 21:51:13 +0000 (16:51 -0500)] 
Improvements per review.

Renaming to use word "Cursor and Accessor" appropriately.

Moved IteratorFromCursor into daffodil-lib-unittest,
rather than have it be deprecated.
Lots of tests have to be edited otherwise.
Similarly the Start and End objects (which have unapply for pattern
matching - that's ok in tests)

Added typed eq/ne named _eq_ and _ne_. These prevent a whole bunch of
errors in the runtime where one accidently compares by eq (for
efficiency), say an infoset node, to an ERD by accident.

Removed need for DPathCompileInfo in InfosetImpl.scala - cleans up this
layering between The DPathCompileInfo and the ElementRuntimeData
objects. See the comments on the DPathCompileInfo trait/class.

Coroutine improvements. Doesn't catch Exception or RuntimeException.

Removed these dangerous catches. Users of InvertControl must put in
their own catches, and propagate them to the consuming side for any
application-specific exceptions. Other exceptions cause the producer to
exit, but the consumer side is notified with a generic wrapper-like
exception and it will abort when so notified.

6 years agoRenaming and file removals per review.
Mike Beckerle [Fri, 18 Dec 2015 21:42:14 +0000 (16:42 -0500)] 
Renaming and file removals per review.

No functional change here at all.

6 years agoRemove target directory of cli from version control.
Mike Beckerle [Fri, 18 Dec 2015 17:17:32 +0000 (12:17 -0500)] 
Remove target directory of cli from version control.

6 years agoIntroduced Cursor, XMLEventCursor
Mike Beckerle [Wed, 9 Dec 2015 22:20:41 +0000 (17:20 -0500)] 
Introduced Cursor, XMLEventCursor

This is about generally getting excess allocation and copying out of the
low-level of the unparser.

Removed UnparserAugmentingInfosetSource.

It just cannot work. It walks the schema, sure, but doesn't evaluate
variables, nor put variables into scope, etc.

Also, since expressions can use dfdl:valueLength and dfdl:contentLength
it isn't possible to augment with calculated values until actually in
the serializer part.

You could perhaps do defaulting, but a whole pass just for that is
silly.

Removed XMLInfosetEventIterator.

This was doing a full pass over the incoming infoset XML events to
synthesize an intermediate thing called an XMLInfosetEvent which is not
quite an InfosetEvent.

Got rid of XMLInfosetEvent, and XMLInfosetEventIterator (used to be
called XMLInfosetIterator)

Re-wrote so that InfosetSource works directly off of XMLEventCursor and
is itself a Cursor, not an Iterator or Stream.

This should be much more efficient.

Also applied as many notions of performance programming (that have been
learned trying to improve the parser performance.)

Added unit tests for InfosetCursorFromTree.

Cleaned up deprecated CursorFromIterator hack.

UState is no longer an iterator.

Got rid of spurious println in many tests.

6 years agoAdd more hexBinary unparsing tests, and set existing hexBinary
Jessie Chab [Sat, 26 Sep 2015 14:40:42 +0000 (07:40 -0700)] 
Add more hexBinary unparsing tests, and set existing hexBinary
parserTestCases to round trip.

DFDL-1364
DFDL-1454
DFDL-1455

6 years agoAdding stylesheet for DFDL tutorial
Beth Finnegan [Thu, 3 Dec 2015 22:11:56 +0000 (17:11 -0500)] 
Adding stylesheet for DFDL tutorial

6 years agoFixed error message w.r.t. fillbyte value.
Mike Beckerle [Tue, 3 Nov 2015 21:36:01 +0000 (16:36 -0500)] 
Fixed error message w.r.t. fillbyte value.

Made OOLAG not swallow illegal argument exceptions.

Changed SDE to be very defensive when doing a toString of a cause
exception. It aborts if anything throws from there.

Created EDIFACT in daffodil-examples

Fixed unnecessary requirement for generateEscapeBlock property

When the escape scheme is an escape-character kind, this property should
not be required.

Changes to support EDIFACT. (Doesn't yet work though)

Temporarilly changed runtime SDE if a variable has been read before
being set into a runtime SDW to work around DFDL-1443.

Added ignoreCase to TermRuntimeData so it will be available when needed
in the runtime. However, nothing looks at it still.

Changed DFA compiler method from 'compile' to compileDelimiter. Too many
things named 'compile'.  Hard to search in the code.

Status: EDIFACT schema compiles, but we get a parse error now:

edu.illinois.ncsa.daffodil.tdml.TDMLException: Parse Error:
Term('CompiledExpression({$ibmEdiFmt:SegmentTerm})') - element.UNB:
Delimiter not found!  Was looking for (<DFA lookingFor=''%WSP*;' />,
<DFA lookingFor='%NL;%WSP*;' />) but found "++1'␊UNH+3" instead.
Schema context: element.UNB Location line 58 column 10 in
file:/home/mbeckerle/Documents/dataiti/git/daffodil/eclipse-projects/examples/target/eclipse/classes/EDIFACT-SupplyChain-D03B/EDIFACT-SupplyChain-Messages-D.03B.xsd
Data location was preceding byte 89 limit(bytes) 806

Changes to allow HL7 example.

Changed dfdl:defineFormat to allow comments to sit before/after the
child dfdl:format element.

The schema compiles (needs -Xmx8G), but it does not yet run
successfully:

Parse Error: Sep('CompiledExpression(|)') - sequence: Found delimiter
(%NL;) for element.HL7::LocalComplexTypeDef::sequence::element.MSH when
looking for Sep(<DFA lookingFor='|' /> <DFA lookingFor='%NL;' />) for
element.HL7::LocalComplexTypeDef::sequence::element.MSH::GlobalComplexTypeDef(MSH.CONTENT)::sequence::sequence
after element.MSH.17.CountryCode and before sequence[1]
Schema context: sequence Location line 1984 column 20 in
file:/home/mbeckerle/Documents/dataiti/git/daffodil/eclipse-projects/examples/target/eclipse/classes/segments.xsd
Data location was preceding byte 82 limit(bytes) 433

Moved DFDLSchemas examples to daffodil-extra.

Bug in setVariable - needs UState for unparsing.

Add binaryNumberRep 'ibm4690Packed' enum to schemas of DFDL schema.

This is used in some of the DFDLSchemas on github, so causes compilation
to fail immediately.

Fixed bug when defaultValue="false" instead of "fn:false()" abort.

Happened in DFDLSchemas ISO8589

Change def to lazy val (efficiency).

Remove duplicate property names from this predefined format.

Note that there were two definitions of outputNewLine. One was CRLF, the
other LF. I have left it as LF.

Added readme to daffodil-examples re: PCAP schema's real home.

...which is on github DFDLSchemas PCAP site.

DFDL-1441, DFDL-999

6 years agoRemoved spurious class
Mike Beckerle [Fri, 30 Oct 2015 17:45:19 +0000 (13:45 -0400)] 
Removed spurious class

Unused functionality that has to be in runtime1, not in core/compiler.

6 years agoadded convenient 1MByte CSV test file
Mike Beckerle [Thu, 29 Oct 2015 17:29:51 +0000 (13:29 -0400)] 
added convenient 1MByte CSV test file

6 years agoEliminated DFAStatus structure.
Mike Beckerle [Wed, 28 Oct 2015 16:35:32 +0000 (12:35 -0400)] 
Eliminated DFAStatus structure.

Reduces allocation in inner loop of DFA (aka tokenizer or lexical
analyzer)

Note: There is still lots of per-element allocation. This just
eliminates the per-character allocation of DFAStatus objects.

Also converts from Seq[Delim] to Array so that we can open-code a
foreach loop as a while loop knowing that the indexing into the array is
constant time.

Added additional scala 2.11 compiler flags to force more aggressive
inlining. Things like OnStack were still allocating closures without
these flags.

DFDL-1415

6 years agoAdded more 'final' keywords to enable inlining.
Mike Beckerle [Wed, 14 Oct 2015 16:51:34 +0000 (12:51 -0400)] 
Added more 'final' keywords to enable inlining.

Added -Yopt-warnings to scalac options - now issues a warning if unable
to inline something labeled @inline. Provides some reassurance that
inlining we have done to avoid allocation of downward closures/funargs
will be implemented.

Removed inlining of Maybe class constructor - was causing
warnings/errors.

Added scala 2.11 additional flags to detect more warnings and potential problems.

Features so we can keep unused Implicits and Equality imports and
suppress the warnings.

Lots of assertNotNull inserted to provide use of local values that
otherwise would generate non-used warnings.

Also a few changes that eliminate dead-code warnings. We can't leave
-Ywarn-dead-code on because there are dead-code warnings we can't do
anything about, but if we turn it on temporarily, then we can fix the
things that are fixable.

Converted with-body methods into @inline final def that are not
polymorphic, and so can be inlined to avoid allocating closures.

Replaced foreach in StatementElementParserBase with while loops.

Removed use of Maybe objects from Infoset (uses Object/null)

Removed use of Maybe objects from MStack of currentInfosetNode in PState
and UState. (uses Object/null)

DFDL-1425

6 years agoRemoved nopub from macroLib.
Mike Beckerle [Tue, 20 Oct 2015 22:32:13 +0000 (18:32 -0400)] 
Removed nopub from macroLib.

It should be nopub, but there is some issue that is causing macroLib to
be required.

DFDL-1430

6 years agoFix deprecation warnings in sbt configuration
Steve Lawrence [Mon, 19 Oct 2015 17:35:20 +0000 (13:35 -0400)] 
Fix deprecation warnings in sbt configuration

- The defaultSettings name was split into multiple variables, we just
  want the core default settings
- The way we created 'sbt new', 'sbt cli', and 'sbt debug' tasks used
  now deprecated methods, but was additionally overly complicated.
  Replace that with much more concise code that won't be deprecated in
  the future and is much easier to understand.

DFDL-1428

6 years agoFix broken test. I removed the ability to setLoggingOff(), but the call
Mike Beckerle [Thu, 8 Oct 2015 14:48:25 +0000 (10:48 -0400)] 
Fix broken test. I removed the ability to setLoggingOff(), but the call
was still there and this test failing.

6 years agoCreated macro-lib project/module, and converted Assert's usage,
Mike Beckerle [Wed, 7 Oct 2015 13:46:04 +0000 (09:46 -0400)] 
Created macro-lib project/module, and converted Assert's usage,
invariant, and notYetImplemented methods into macros.
macro.

ECLIPSE SETUP CHANGE: you must add -language:experimental.macros option
to the scala compiler settings. This setting is not set in our git
repository eclipse-projects, but is a global setting for the entire
eclipse instance (or maybe workspace?).

Unit tests of macro-lib are in daffodil-lib-unittest

Converted logging system to use macros.

This eliminates all these Glob objects, and closure forming.

The way to log now is log(LogLevel.Debug, "something %s", args...)

DFDL-1425

6 years agoRefactored OnStack so we have LocalStack which avoids the ThreadLocal
Mike Beckerle [Thu, 3 Sep 2015 19:02:56 +0000 (15:02 -0400)] 
Refactored OnStack so we have LocalStack which avoids the ThreadLocal
overhead when we already have a thread-local state object, which we do
in the PState/UState, and DataInputStream and DataOutputStream objects.

No point paying for access to a ThreadLocal when it can just be a data
member of the state that is already thread-local.

Removed call-by-name from Maybe.getOrElse. Requires rewriting things
that use it as a control structure (e.g., which throw or assert in the
body arg) using if-then-else.

We badly need macros!

MaybeLong, MaybeInt, MaybeChar, MaybeBoolean classes added.

Changed DataInputStream API to avoid allocation (which Maybe[Long],
Maybe[Double] etc. were causing). Now throws
DataInputStream.NotEnoughDataException if there isn't enough data, but
can check in advance by calling isDefinedForLength(nBits): Boolean which
replaces use of a Maybe type for Long, Double, Float.

Rebase onto 2.11 scala.

Fix compilation error in cli Main.scala
Update TestLogger because until log is a macro, it now evaluates its
arguments.

DFDL-1424, DFDL-1212

6 years agoscala 2.11-specific scalacheck version.
Mike Beckerle [Tue, 6 Oct 2015 21:40:32 +0000 (17:40 -0400)] 
scala 2.11-specific scalacheck version.
eclipse classpath src and doc attachment

6 years agoscala 2.11-specific scalacheck version.
Mike Beckerle [Tue, 6 Oct 2015 21:40:32 +0000 (17:40 -0400)] 
scala 2.11-specific scalacheck version.
eclipse classpath src and doc attachment

7 years agoClasspath changes to build in Eclipse with scala 2.11
Mike Beckerle [Fri, 2 Oct 2015 16:30:38 +0000 (12:30 -0400)] 
Classpath changes to build in Eclipse with scala 2.11

Note: default scala Compiler flag change (-Xxml:coalescing) is also
needed for Eclipse configuration. This is not part of each project, but
is specified for each eclipse workspace.

gitignore for .cache-tests and .cache-main directories (which
Eclipse-Mars version creates?)

7 years agoUpdate to scala 2.11
Steve Lawrence [Mon, 28 Sep 2015 13:44:21 +0000 (09:44 -0400)] 
Update to scala 2.11

- Mostly just replaced deprecated functions and make functions protected
  where necessary.

- Add a fix to allow @transient to work on constructor parameters.

- Fixes for many namespace changes. It appears that the scala-xml module
  fixed a handful of bugs related to namespaces. This broke the
  DaffodilConstructingLoader, because we weren't correctly modifying
  scopes to include dafint (we added the scope bottom up rather than top
  down, which meant that child elements weren't properly sharing the
  dafint namespace binding with their parents, so every element had what
  appeared to be a unique dafint namespace binding. This was why when
  looking at a schema dump you would see the xmlns:dafint namespace
  declared on every element. This changes the way we construct those to
  build the namespace properly. This fixed a handful of namespace
  issues that cropped up with 2.11.

- Pull in changes from scala-xml in the PrettyPrinter that change the
  default top scope from null to TopScope. Without these fixes, the
  namespace xmlns="" was incorrectly added in some cases.

- Add the -Xxml:coalescing compiler flag, which prevents scala-xml from
  coalescing nodes. This allows us to keep the PCData information around
  and properly coalesce for our needs.

- Fixes removal of all whitespace text nodes. We don't actually want
  that. Now that PCData and Text nodes remain separate, it's possible
  that we have whitespace text nodes inbetween PCData nodes. This is
  perfectly acceptable, and we do not want to remove those whitespace
  nodes. What we really want to do is remove white space nodes that are
  mixed with Elem nodes. This changes XMLUtils to perform that action.

DFDL-1211