What's fixed

What's fixed in OmniMark 10.1.1

What's fixed in the OmniMark 10.1.1 compiler

The l and u modifiers were being rejected on %eq. This was contrary to the specification.
If an undeclared identifier was supplied to a module in an import declaration, a non-sensical error message was emitted.
An internal error could be triggered if a value argument was passed as a shelf-class argument to a shelf-class function, and the result of the function was used in a repeat over.
Error recovery has been improved when a do select-type is missing the required alias.
An internal error was triggered at compile-time if an invalid new expression of type markup sink appeared as an argument of a string sink or markup sink function.
The attribute alias in a repeat over attributes or repeat over specified attributes loop was being converted to a string value and back upon assignment to a shelf. This lead to the loss of the attribute's declaration in the target shelf.
An incorrect error message was being emitted at compile-time if the optional argument initializers did not agree between a dynamic function and one of its overriding functions. The correct error message is now emitted
A conditional operator containing ancestry expressions in its alternatives would trigger an internal error at compile-time.
An internal error could be triggered at compile-time if content was used on the left-hand side of a set, in a context where no shelf called content was previously-declared.
An overloading of name of could not be declared dynamic.
An internal error could be triggered if a syntax error occurred in the guard of a rule
An overloaded infix-function with either argument declared to have type markup-element-event could not be invoked using an element expression in that position.
An internal error was triggered at compile-time if a shelf-class function call was used as the dispatch argument of a dynamic function.
An internal error could be triggered at compile-time when parsing a syntactically-invalid element test
An internal error was triggered at compile-time if a cast appeared in the head of a do select-type.
A segmentation fault would occur at compile-time when attempting to apply new to an optional value function argument, inside an is specified test.
Constant propagation was incorrectly being applied to the alias in a repeat over loop. This would lead to incorrect results at run-time.
The compiler would lose track of %c or #content if it happened to be used as the argument of an overloaded function call. This could cause correct programs to fail to compile.
An internal error could be triggered at compile-time if content appeared in a process rule, in certain contexts.
An internal error could be triggered at compile-time when a markup source function's signature did not match its declaration.
An internal error was triggered at compile-time when a stream field of a record instance was used in a branch of a conditional operator, in the head of a using output as scope.

What's fixed in the OmniMark 10.1.1 runtime

After a throw from a markup source function used by do markup-parse, the scope within do markup-parse terminated without a proper cleanup. This could lead to resource leaks, internal errors, or segfaults.
Passing create-element-event an attribute shelf item with an empty string for a key would cause a segmentation fault at run-time.
Expressions beginning with attributes of create-element-event could lead to a segmentation fault at run-time.
Invoking create-unspecified-attribute multiple times could lead to an infinite loop.
The result of declaration of attributes of create-element-event was not always correctly initialized. This could lead to a run-time error or segmentation fault.
Returning a keyed shelf item from a shelf-returning function would remove the item's key.
A second attempt to consume the same #content after the first was interrupted could drop some data content.
Casting the result of create-specified-attribute to a specified-attribute and then accessing its value could cause an internal error at run-time.
Invoking a pattern function with a do scan action from a markup-error rule could cause an internal error at run-time.
If a value-returning function made a call from within an always clause to a coroutine function which called another function returning the same type of value, a program error could be issued even though there was no error.
Passing a join to a function that pattern matches ahead on the source could leave the source in an inconsistent state, potentially leading to corrupt output or a segmentation fault.
Using create-element-event only to fetch an attribute of the result could cause a segmentation fault.
If #content was only partially consumed, the remaining unpaired #markup-end events would appear in reverse order.
Failing to close a stream attached to a referent by the end of the nested-referents scope the referent was bound to could lead to a segmentation fault at run-time.
An external text entity event generated by a parse that was emitting only #content, and then getting processed by a do markup-parse in a different markup sink coroutine, could cause an internal error and segmentation fault.

What's fixed in the OmniMark 10.1.1 libraries

The OMFTP library would fail when attempting to perform data transfers (for example, uploading files) if the host was a recent Linux distribution.
When trasferring files to or from certain FTP servers using FTPConnectionRemoteOutputFile or FTPConnectionRemoteInputFile, the operations could fail with error OMFTP002.
The netutil.host-ip function in the omnetutil library would return a useless value when querying for the address of the local host.

What's fixed in OmniMark 10.1.0

What's fixed in the OmniMark 10.1.0 compiler

The warning emitted when a shelf was unused was unclear.
The compiler was incorrectly accepting an expression of type stream where one of type markup sink was expected. This is contrary to the specification, and is no longer allowed.
A signal to action inside a catch clause could cause incorrect code generation, possibly leading to an internal error at run-time.
A spurious warning could be emitted when using an alias to output an item of the specified attributes pseudo-shelf.
A specific ancestry selector was being accepted on the left-hand side of an element test. This is contrary to the specification, and allows for misleading programs. This is no longer permitted.
A spurious warning was output if the key of operator was the sole operation applied to a shelf that had been assigned a value.
An incorrect error message was output if with document-element appeared out of sequence in a do sgml-parse or do xml-parse action.
An incomplete error message was emitted when an invalid character class declaration was encountered.
A segfault was triggered at run time when calling a shelf-class function with a coroutine class argument.
New style indexers were being incorrectly rejected in function call arguments when the argument was shelf-class (e.g., read-only).
The OmniMark compiler would accept a dynamic function definition whose export status did not match a previous elsewhere definition of the same function.
A set of circular extended record declarations could incorrectly cause compiler error report.
OmniMark did not always detect at compile time and report the error that a record type requires infinite initialization depth.
An incomplete error message was emitted when a string set was left unclosed.
An internal error was triggered at compile-time when an instance of an opaque type occurred in a branch of the conditional operator, in a context where a string source or markup source was expected.
An internal error could be triggered at run-time if a string source function call with a shelf-class argument (e.g., read-only) was passed as a value string source argument to an outer function call, and the argument of the inner function call was an alias from do select or do select-type.
An internal error was triggered at compile-time if an overloaded function was defined on a required record type.
A dynamic function could be defined both with and without an overloaded qualifier. This is not well-defined, and is no longer allowed.
An internal error was triggered at compile-time if a value of type specified-attribute was compared to a value of type integer.
Compile-time error recovery has been improved when a type name was encountered in an unexpected context.
A segfault could occur if a run-time error occurred while accessing the attributes in the guard of a rule.
Using the same alias twice in the header of a repeat over loop could crash the compiler if one of the aliased shelves was a shelf literal.
Duplicate shelf names were being allowed in the header of a repeat over. This is contrary to the specification. This had been an error in versions of OmniMark previous to 10.0.0. The error has been re-instated.
An internal error could be triggered at compile-time if new was applied to an invalid value in the header of a using scope.
In some contexts, a shelf-class function call could lead to a segmentation fault at compile-time.
A repeat over of a shelf with a fixed-size of zero could lead to a cascade of incorrect compile-time errors.
OmniMark compiler was allowing #current-input in process rules, even though it was not attached and bound to fail at run-time.
In certain situations, a segmentation fault could occur at run-time when a shelf literal or shelf-class function appeared in a rule guard.
The compiler was incorrectly accepting an ELEMENT qualifier on DOCTYPE, in certain contexts. This is contrary to the specification, and is no longer accepted.
Attempting to apply a shelf test (e.g., is specified) to the result of a function call could trigger an internal error at compile-time.
An internal error could be triggered at compile-time if the is keyed test was applied to the attributes shelf.
A segfault occurred at compile-time if an syntactically-invalid indexer was used with attributes
A shelf-class function call was not being handled properly in the context of a stream test.
Casts to built-in types like markup-element-event inside a module that didn't import other modules would cause a compile-time internal error.

What's fixed in the OmniMark 10.1.0 runtime

Run-time error messages that refer to sink coroutines now correctly report their return type.
The sgml-in and sgml-out actions were erroneously affecting the validating XML parser as well.
A throw from an external-text-entity rule triggered by do markup-parse could lead to an invalid memory access.
If #current-dtd and #doctype are set to incompatible values, and the subsequent program error thrown by #content was caught, it was possible to trigger an internal error or incorrect behaviour.
A pattern function that ends without returning a value could trigger an internal error after the legitimate program error.
Capturing #current-markup-event on an element with a namespace-binding attribute was leaking memory.
Accessing attributes or specified attributes of an element created by create-element-event could trigger an internal error or a segmentation fault at run-time.
When reporting long file paths in error messages, OmniMark now inserts an ellipsis to better indicate that the file path is truncated. It also removes the middle of the overlong file path instead of its end, which is more informative.
An internal error could result if the target coroutine of signal throw performed a throw back to the original coroutine through intermediates.
A long processing instruction text could cause a segmentation fault when consumed through #content.
A throw from a markup rule triggered by do markup-parse #current-input inside a markup sink function could cause a memory leak or a segmentation fault.
Applying do markup-parse to a markup source containing external text entity references in some circumstances could lead to a segmentation fault.
Consumption of #content would lead to a segmentation fault if it included the end of an external text entity, but not its beginning.
The repeat over attributes action could segfault on an element that has both declared but unspecified, and undeclared but specified attributes.
An element event with an empty element name, created using create-element-event and create-element-declaration, could cause a segmentation fault when processed by do markup-parse.
Entity-matching translate rules could cause memory corruption and segmentation faults on large data content blocks.
The indexing mode was not being preserved when the attributes shelf was passed to a function as a read-only argument.
Consuming #content twice inside a do markup-parse scope lead to a segmentation fault.
An element event returned by create-element-event did not have xmlns-name assigned even if its attributes specified one.
Multiple occurrences of the same attribute name in an ATTLIST were reported as markup errors both in SGML and XML. The behaviour of the validating XML parser has been changed to a markup warning, in conformance with the XML specification, and only the first attribute declaration is kept.
An empty ATTLIST declaration was reported as a markup error in validating XML parser, even though the XML specification allows it.
The well-formed XML parser used to issue markup errors on characters like backspace, which are discouraged but allowed by the XML specification. This error has been replaced by a markup warning.
A malformed XML processing instruction could cause an internal error in OmniMark's well-formed XML parser, abruptly terminating the current parse.
Applying do markup-parse to a markup source function with an argument that was another string source function followed by drop could cause an internal error.
An external-text-entity #document rule could in some rare circumstances cause a segmentation fault in the interpreter during the loading time.
Library file path command-line parameters starting with a // or /./ character sequence could trigger a memory corruption or segmentation fault.

What's fixed in the OmniMark 10.1.0 libraries

The execute function in the omprocess library would not always allow the invoked process to consume all of its standard input, when used on Windows platforms.
Function uri.canonical was properly working only on local URIs, with no server.
Function uri.canonical was stripping the double-slash sequence into a single slash even before the path segments. The result was an incorrect URI.
Function uri.canonical was normalizing the fragment portion of the URI. The function now conforms to the standard and leaves the fragment unmodified.
The omxerces library could cause a segmentation fault if given an XML schema with a large maxOccurs integer attribute value.
The omxerces library was not firing the external-text-entity rules for entities whose system identifier was an empty string.
The omxerces library could cause a segmentation fault when applied to a malformed XML with a schema declaration.

What's fixed in the OmniMark 10.1.0 Studio for Eclipse

OmniMark Studio now shows more detailed information about markup event values.

What's fixed in OmniMark 10.0.0

What's fixed in the OmniMark 10.0.0 compiler

A warning is now emitted if a domain-bound global is never saved.
In some circumstances, the line number information given for a compile-time error that followed the export keyword was incorrect.
The types of the branches of the conditional operator were not being unified if the closest common supertype was not exported from the module exporting the child types.
The types of #current-input and #current-output were not being tracked properly, allowing invalid programs to compile. This is contrary to the specification, and has been fixed.
A record type could not be elsewhered after it had been fully declared.
Using key of on a single-item unkeyed record field could lead to a segmentation fault at run-time.
In some circumstances, the compiler rejected a built-in stream in the header of using output as.
The value-start and value-end positional patterns were not allowed in processing-instruction rule headers.
Certain record type hierarchies could cause live record instances to be garbage-collected.
An incorrect error message was emitted by the compiler if with current sgml-dtd was used with subdocument in do sgml-parse.
An internal error was triggered at compile-time if a pretentious module referred to a predefined shelf.
The compiler accepted multiple occurrences of the keyword new where only one is allowed.
The compiler accepted an optional argument in the first position for a dynamic or overriding function. This is not well-defined and is now rejected.
The compiler allowed a constant item indexer on a shelf literal to exceed the size of the shelf literal.
The compiler accepted invalid type variances on the return types and arguments of dynamic and overriding functions. This is contrary to the specification, and is no longer allowed.
The error message emitted when attempting to save a shelf literal was misleading.
The error message emitted when applying save to a built-in shelf was incorrect.
An internal error was triggered at compile-time if a function imported from a module conflicted with a require.
The successful compilation of a call to an overloaded function in a pattern context could depend on the order of the definitions of the overloadings.
The compiler would accept copy from a fixed-size shelf to a variable-size shelf, even when the former was larger than the latter. This cannot succeed at run-time and must be disallowed.
Two-token keywords ending in of, as for example length of, were being rejected if they appeared as a function argument and the following function argument was heralded by the second token of the two-token keyword.
The parent type in a record declaration could differ from that given in the elsewhere declaration. This is contrary to the specification and is no longer allowed.
using input as "%c" was not always tracking the use of %c, which could lead to correct programs not compiling.
An overloaded switch function with a non-parenthesized argument list was not being accepted when compiling patterns for take, drop, and matches.
The error messages on the uses of the previous is test in various disallowed contexts were always reporting the content keyword as being disallowed.

What's fixed in the OmniMark 10.0.0 runtime

Existence of markup-comment and marked-section rules could affect the boundaries of translate rules' pattern matching across the module boundaries. This is now restricted only to the rules within the same module.
The remove action could fail when applied to a shelf item created by using new inside the scope.
The content-start and content-end patterns in translate rules were not firing only at the beginning and end of element content, as they were supposed to.
Interrupting consumption of #content of an element with an XML namespace change could trigger an internal error.
The validating XML parser was not treating numeric character entities entered in hexadecimal as it was treating numeric character entities entered decimal. These two should be treated equivalently.
A guarded new could fail when the maximum shelf size was reached, even when no new item was being added to the shelf.
Dynamic element name tests could fail when applied to element events created by do markup-parse.
A markup event explicitly signalled from a pattern function through an intermediate coroutine and to a markup parser could be parsed before preceding data content.
In certain circumstances, a markup error could mislead OmniMark into thinking a stream was opened, when in fact it was closed.
The name of an SGML external entity captured by #content was sometimes incorrectly reported as a part of the SGML declaration.
The -FTRACE command-line option could cause incorrect program behaviour in functions called from a markup-error rule.
Catching a throw from an external-text-entity rule and then continuing to feed the parser could cause a segmentation fault.
A do markup-parse command applied to a join of xerces.xml external parser and another markup source could cause a segmentation fault at run-time.
Consumption of a markup source after catching a throw could erroneously lead to a markup event being thrown in a wrong coroutine.
The previous is test always failed on the top-level element, and its occurrence was always one.
The dynamic element name tests could fail on element events that were not generated by a the currently active parse.
The previous is test could return random results inside a do markup-parse consuming events from parses that were not active any more.
A throw from an external string source function was not being propagated if the function was called in the setup of a pattern matching environment.

What's fixed in the OmniMark 10.0.0 libraries

The function uri.parse did not accept a URI that contained nothing but the URI fragment.
If a markup-buffer was written to through multiple sinks, the order of the written string data was determined by the order in which the sinks were closed. This could lead to unexpected results, so this has been changed so that the data order depends on the order in which the sinks are open.
Compiling a RELAX NG schema with the RELAX NG collection elements in a namespace other than the default one caused an internal error.
The omxmlwrite library was producing well-formed XML even when its input markup stream was malformed.
Certain circular references in a schema could cause an internal error in relaxng.compile-schema.

What's fixed in the OmniMark 10.0.0 grammar

The grammar production for a user-defined name character referred to the deprecated letters declaration.
The production for a name referred to data characters.
field references had been omitted from the grammar.

Related Topics