What was fixed

What's fixed in OmniMark 9.1.0

What's fixed in the OmniMark 9.1.0 compiler

  • A warning is now emitted if a string function outputs to its inherited #current-output.
  • If the initial clause of an optional argument for a function contained %c, and the function was invoked in an element rule without specifying an argument, the compiler rejected the program on the basis that %c was not being processed in the element rule.
  • An internal error could be triggered if the second branch of a conditional operator contained a pattern expression in a non-pattern context.
  • An incorrect warning was emitted if the key of shelf query was applied to a field access whose record was specified as an expression.
  • It was possible for the compiler to get into an infinite loop if a program contained an elsewhere declaration of a record type that extended a parent type which was in turn referenced as the type of a field of the original record type.
  • A do select-type statement applied to an instance whose dynamic type is not explicitly specified as one of the clauses could fail to execute its parent clause.
  • An incorrect file name/line number combination was given when a duplicate function definition was encountered
  • An internal error was triggered at compile-time if ||* appeared in a shelf initializer.
  • A spurious warning was emitted when #console was encountered in a program.
  • In a context where #current-input is a markup source, it could be used in a context expecting a string source. This is contrary to the specification, and is now disallowed.
  • It was possible to trigger an internal error with a malformed import declaration.
  • In some circumstances, an invalid overriding function definition could lead to an internal error at compile time.
  • An internal error was triggered in the compiler if a static cast appeared in the dispatch argument of a call to a dynamic function.
  • The as opaque qualifier on an exported record declaration did not have to match that of the corresponding elsewhere. This could allow record fields to be visible in contexts where they should not have been; this is contrary to the specification and should not have been allowed.
  • An incorrect error message was emitted if an & was encountered where a | was expected, and vice versa.
  • An internal error was triggered if a catch was declared to take a value string source argument, and subsequently used in an external-text-entity rule.
  • The warning that number of was being applied to a fixed-sized shelf was being emitted too aggressively, leading to too many false warnings.
  • The warning emitted when a shelf is unused or uninitialized now points to the location where the shelf was declared, instead of the location of the end of its scope.
  • If the filename specified by the -depend command-line option could not be opened, an incorrect error message was output, followed by a segmentation fault.
  • An internal error was triggered if an initializer was specified on a optional markup source argument in an elsewhere definition of a function.
  • A segfault occurred if an optional markup source function argument specified a constant string as an initial value.
  • An initializer could not be specified for an optional markup sink argument in an elsewhere definition of a function.
  • An incorrect error message was emitted if #suppress was used as the initializer for an optional string sink argument, and both elsewhere and as definitions of the function were present in the program.
  • An internal error could be triggered at run-time if a processing-instruction rule failed to match the input, and a subsequent one succeeded.

What's fixed in the OmniMark 9.1.0 runtime

  • A throw from a string sink function that passes its #current-input to a string source function, whose output it then parses, could cause an internal error in OmniMark.
  • Error message 6143 has been improved to report both the expected and encountered end tag in case of mismatch.
  • In some circumstances, it was possible for the has key test to fail even though an item existed with such a key.
  • A markup error that triggered a markup-error rule could cause a memory leak.
  • A markup error event could be counted more than once in #markup-error-total if a markup-error rule signalled its #current-markup-event to another markup-parse.
  • The %c consumed in a streaming fashion inside a data-content rule would be interrupted by CDATA and SDATA entities.
  • A program error inside a signalled coroutine could cause a segmentation fault.
  • Garbage collection could cause a segmentation fault.
  • Throwing from a do markup-parse consuming #content of an element that changes the namespace could cause an internal error.
  • Removal or setting a key of a new shelf item caused a run-time error. This is now allowed.
  • A throw from a nested coroutine caught in its parent could cause the grandparent to die with no error reported.
  • A segfault was triggered when a PI entity with empty value was encountered and fired either a processing-instruction rule or a translate rule containing the named pattern.
  • The validating XML parser would reject the entity reference < in attribute values.
  • A misleading error message was emitted when attempting to access a non-existant element attribute during a well-formed parse.
  • Attempting to use a compiled DTD in a validating XML parse, and specifying an empty string for the document-element parameter would lead to a segmentation fault at run-time.

What's fixed in the OmniMark 9.1.0 libraries

  • A TAB character in the data fed to the omxmlwrite library could lead to a character entity in the output appearing in a context where one is not allowed.
  • A conversion function from string to markup-buffer has been added to markup utilities.
  • Two markup-buffer values can now be compared for equality of their contents using the = and != operators.
  • The omrelaxng validator did not always accept a valid instance of an attribute value in case the schema specified each alternative value model together with the repeated attribute name.
  • relaxng.compile-schema could return an invalid schema object for some heavily recursive RELAX NG schemata.
  • Character entities emitted by the omxmlwrite library are now emitted in a hexadecimal representation.

What's fixed in OmniMark 9.0.2

What's fixed in the OmniMark 9.0.2 compiler

  • A memory leak would occur at compile time if certain errors were encountered while parsing a module and the error threshold limit was crossed.
  • Entity patterns would allow entity patterns for the named and valued components. These could never match, and so are now rejected at compile time. This may cause programs that previously compiled successfully to stop compiling. The solution is to remove the offending pattern.
  • The error message emitted when encountering a keyword hidden by a user declaration gave no indication of where the keyword was hidden.
  • An inaccurate compile-time error message was emitted when a markup parsing block did not contain a %c, suppress, or #content.
  • A misleading error message was emitted at compile time if the arguments to do sgml-parse appeared in the wrong order.
  • optional argument pass-through can now be used in a context where a conversion-function would otherwise have been invoked. Previously, this had led to a run-time error.
  • The namecase declaration could affect whether or not a program compiles. This declaration is deprecated, and has no effect on program compilation or program execution.
  • An error message was emitted if a module exported the predefinition of a function, but the function was never invoked. This impedes early prototyping of modules, and has been relaxed to a warning.
  • A needlessly confusing error message was emitted at compile time if | appeared where a || was expected.
  • Using the new operator as an argument to a function could lead to erratic behavior at compile time.
  • Using new on a field access in an open action could lead to erratic results when the type of the shelf item was incorrect.
  • Using the name of operator in an erroneous context could lead to erratic results.
  • Conflicting definitions of dynamic functions could lead to a segmentation fault at run-time.
  • An internal error could be triggered at run-time if multiple shelf literals appeared in different match clauses of a do scan block.
  • A function predefined as dynamic and later defined as not dynamic could trigger an internal error if the latter had no arguments.
  • A misleading error message was triggered when name of was applied to a function.
  • A misleading error message was triggered when set was applied to a function other than a string sink or markup sink function.
  • An internal error was triggered if either #content or #current-markup-event was used in a shelf context (e.g., passed to a function as a read-only argument).
  • In certain error messages, the built-in type markup-region-event was being described as user-defined.
  • A conditional operator containing a pattern variable in one of its two branches could lead to unpredictable behavior.
  • If a module exported the predefinition of a conversion-function that was needed in an importing module, an inaccurate error message was emitted.
  • A nonsensical error message was emitted if a throw to a catch target had a comma-delimited argument list and was missing an argument.
  • A spurious error message could be emitted if an optional argument of type integer had an initial clause with a type other than integer.
  • A warning is emitted at compile-time when the instance keyword is used to invoke the well-formed XML parser.

What's fixed in the OmniMark 9.0.2 runtime

  • Processing instructions captured by #content were causing memory leaks.
  • Signalling to a string sink function whose #current-input is being consumed by a string source function could cause a subsequent signal from the latter coroutine to be misdirected.
  • After a program error from a signal throw destination coroutine, the always clauses in the signalling scope would not run.
  • The second of two signal throw actions with no intervening output could end up being uncaught if the target coroutine delegated its work to another coroutine.
  • If two signals were sent with no intervening data to a coroutine that delegated its input processing to another coroutine that would die after the first signal, the second signal would not be caught.
  • Signalling to a string source coroutine wrapped in a string sink coroutine could cause a segmentation fault.
  • Certain element name tests like previous is could fail inside a do markup-parse.
  • A segmentation fault occurred at run-time if a stream was attached with referents-allowed to a referent that had previously been attached to a stream with referents-allowed.
  • Processing of %c in a different coroutine than the one that started the parse could lead to uninitialized memory access.
  • A complex markup-processing pipeline could cause a segmentation fault.
  • If the last coroutine signalled in a chain of coroutines suspended by outputting instead of asking for input from the first one, the next signal could become uncatchable.
  • Using signal throw on a coroutine that has already terminated could cause a segmentation fault.
  • A chain of functions of markup sink, markup source, and markup sink return types, each invoking the next in turn, could cause a segmentation fault.
  • Wrapping a source coroutine in a sink coroutine and using the latter one could change the program behavior.
  • copy and save applied to a stream containing referents could lead to incorrect output or internal errors.
  • Outputting the %c directly could behave differently from passing it as a value markup source function argument and outputting the argument.
  • A copy or save of a stream opened with referents-allowed and then closed could lead to a later segmentation fault.
  • Malformed markup errors could lead to memory leaks and memory access errors
  • Some complex signalling coroutine pipelines could deadlock.
  • As part of a complex pipeline, %c and #content in a markup-comment rule did not behave the same.
  • Replacing a markup source function in a pipeline by an equivalent function of markup sink type could cause markup event signals to not be caught.
  • A throw from an element rule triggered from a markup sink function could cause a memory leak.
  • Use of an external string source function in a markup-processing pipeline could cause an internal error and bad memory access.
  • Signalling a markup event to multiple destinations could cause an erroneous run-time error.
  • Access to #current-markup-event in an element rule from inside a %c scanning scope yielded the last parsed element instead of the element that triggered the rule.
  • Complex markup-processing pipelines could sometimes hang.
  • An external text entity reference could cause an internal error when parsing an already started coroutine.
  • Complex markup-processing pipelines could leak memory.
  • Well-formed XML parsing of repeated elements of same name but with different attributes, conducted concurrently with a do markup-parse of the element events, could lead to an internal error or wrong behavior.
  • If an external text entity event was passed to a do markup-parse and the original parse was killed immediately after that, an internal error would result.

What's fixed in the OmniMark 9.0.2 libraries

  • Invalid UTF-8 character could be generated by the omxerces library, for valid UTF-8 input.
  • Function uri.parse in OMURI library, when given a relative path, was incorrectly providing both the relative and absolute path in its uri-components argument.
  • The functions utf8.code-point and utf8.multi-byte-char in the library omutf8 accepted so-called overlong sequences.
  • The uri.parse function from omuri now decodes the hex-encoded characters.
  • Function uri.parse in OMURI library failed to parse URIs with registry names containing special characters.
  • The OMVFS library in the Development Package came without the certificates file.

What's fixed in the OmniMark 9.0.2 markup parsers

  • The well-formed XML parser could report an internal error if the coroutine producing its input suspended inside a processing instruction.

What's fixed in OmniMark 9.0.1

What's fixed in OmniMark Studio for Eclipse 9.0.1

  • An internal error was triggered when debugging a program containing a do select construct.
  • If fields of a record instance were expanded in the variable view before stepping over an action that releases the record instance, debugging could not continue.
  • remainder function arguments did not show in the variable view during debugging.
  • A scanning datascope was not being created when a string sink function was invoked.
  • The Use default working directory checkbox in OmniMark launch configuration was always reverting to active state.
  • The -reqkeygen command-line option was outputting a wrong error message when used incorrectly.
  • Garbage could appear at the end of a referent value.
  • When debugging a program that imported OMFLOAT or OMBCD, the first breakable line was incorrect.
  • element end tags were duplicated in the right pane of the Parsing Sources view.
  • Type names for shelf literals in the global scope were not being properly initialised. This could lead to erratic behavior.

What's fixed in the OmniMark 9.0.1 compiler

  • The code generated for access of constant values has been improved.
  • A spurious warning was emitted if the only use of a shelf was number of.
  • A constant shelf item could not be used as an initializer in an elsewhered function definition.
  • The error message emitted when a duplicate or colliding I/O declaration was encountered was needlessly confusing, and lacked information that could help the user correct the problem.
  • The error message emitted for conflicting function definitions pointed to the wrong line number.
  • A spurious empty pattern warning could be emitted if the single item of a constant string shelf appeared in a pattern.
  • A markup source called within the body of a do xml-parse or do sgml-parse scope was unable to signal markup events.
  • A reference to a constant shelf declared with an empty initializer is no longer allowed in a value context: a compile-time error is now emitted. Such a reference would have triggered a run-time error in previous versions of OmniMark.
  • Invalid numeric values were being accepted when initializing an integer from the command-line using the -c command-line option.
  • Valid format items (e.g., "%q") were being rejected in optional argument initializers.
  • An escape declaration in a module could affect the importer, and vice versa.
  • Setting the escape character to certain letters or the space character could make compilation fail.
  • Certain combinations of nested modules containing macros could lead to a valid program being rejected at compile time.
  • Using the %g format item on an optional string function argument inside of a conditional operator could lead to an incorrect run-time error about accessing an unspecified optional argument.
  • An escape declaration in a program containing a not-reached with no argument or an asserg with no argument could cause the otherwise valid program to be rejected.
  • An internal error was triggered when the types of the with modifier specifier were incorrect.
  • An incomplete error message was emitted when an external conversion-function did not specify an external library binding.
  • In some circumstances, the #base and #full element rule lists were not both being searched.
  • An internal error was triggered at compile-time on the sequence stream output.

Fixed in the OmniMark 9.0.1 runtime

  • Opening a large number of files with referents-allowed could exhaust the number of file handles available.
  • A failure to resolve the #dtd external text entity to a file could lead to a segfault if the #content from the failed parse was fed to do markup-parse.
  • The error message "A disallowed stream operation was attempted" came with the error code 6030 which was already in use. The error code has been changed to 6146.
  • Use of #content in a data-content rule led to an internal error.
  • A large contiguous data content region could cause a buffer overflow when consumed through #content.
  • Partial scanning of %c could cause an internal error.
  • A cdata or rcdata marked section could lead to a segfault at run-time if no rule fired in response to the event.
  • A string source literal directly passed as a value string source to a function did not match value-start.
  • Default external-text-entity rule was using #library and #libpath shelves from the module where the markup was first parsed, not from the module with the do markup-parse action that triggered the rule.
  • An internal error could occur if %c was scanned or submitted in presence of a markup-error rule.
  • A markup-error rule that performs a signal throw of its #current-markup-event into a markup-processing pipeline could cause an internal error.
  • An internal error was triggered if consumption of #content was interrupted more than once and then continued from inside a markup comment region.
  • If the creating sgml-dtds or creating xml-dtds clause was used, the content had to be processed by %c or suppress, as #content attempted to parse beyond the DTD end.
  • If do markup-parse was directly applied to a %c, external text entity references were being attached to the inner parse instead of the outer one. This could lead to input corruption and internal errors.
  • A signal throw sent to a coroutine that was delegating their handling to another coroutine could not always get through.
  • The external-text-entity rules triggered by a do markup-parse were inheriting domain-bound global variables from the domain of the original parse, not the parse that triggered them.
  • A shelf of an abstract type could not be saved.
  • An attempt to process content from the markup input coroutine could raise an internal error instead of a catchable program error.
  • Use of %v on a CDATA attribute could cause an internal error if a translate rule suspended to a different coroutine.
  • Throwing from inside a parse launched from a coroutine used as an input to another parse could lead to an internal error.
  • A resignalled markup error event could cause a segmentation fault at run time.
  • A sequence of user-created markup errors passed through several markup filters could lead to a segmentation fault.
  • Character references &#nnn; could be corrupted when captured by #content and then recaptured.
  • If an external text entity event was pipelined through more than one markup-parse before being handled, an internal error was reported.
  • If a do markup-parse action was applied to a malformed stream where a markup-comment region contained markup events, an internal error was reported instead of a program error.
  • The Solaris 10 native build of OmniMark could suffer from degraded performance in certain circumstances.
  • The test last content is #data would return an incorrect result if the only data were character entity references.
  • In some circumstances, using a dynamic element name in a string source function feeding a markup parse could trigger a segmentation fault at run-time.
  • A line break in markup comment coud cause the rest of the comment to be lost if the output of markup-comment rule was processed by another coroutine.
  • The newline (LF) characters inside the #content of a markup-comment, invalid-data, or markup-region ignore would be expanded into the CR LF character sequence.
  • An internal non-text entity followed by a PI entity was being expanded twice.
  • A signal thrown to a chain of alternating markup sink and markup source functions could end up uncaught.

Fixed in the OmniMark 9.0.1 markup parsers

  • Invalid processing instructions were being accepted by the well-formed XML parser. A markup error is now being emitted for invalid processing instructions, however processing-instruction rules continue to be triggered as before, to maintain backwards compatibility.
  • The validating XML parser was accepting invalid marked sections in the instance of an XML document. Markup errors are now being triggered for invalid marked sections in the instance of an XML document when performing a validating XML parse, however any related rules (e.g.,marked-section ignore) still fire, as before. This limits any backwards compatibility issues.
  • #doctype was not being attached for a well-formed XML parse, even though the input contained a DTD.
  • dtd-start and dtd-end rules were not being fired when a well-formed XML parse was launched and a DTD was present in the input. This could make it difficult to write generic markup handling code. The behavior is now consistent across all parse types.
  • The validating XML parser would accept < in attribute values. This is forbidden by the XML standard, Section 3.1. A markup error is now triggered when a < is encountered in an attribute value, but parsing continues as before, to maintain backward compatibility.

Fixed in the OmniMark 9.0.1 libraries

  • An internal error was triggered when validating against the RELAX NG schema for XHTML.
  • In the omrelaxng library, the ns attribute was not being inherited for include elements.

What's fixed in OmniMark 9.0.0

Fixed in the OmniMark 9.0.0 compiler

  • A pattern variable could not be used in a sub-clause of the same pattern, if it was enclosed using the x or g format item.
  • An unhelpful compile-time error message was emitted for the expression name of notation named "a".
  • The warning emitted when a shelf was not properly initialized did not contain file name/line number information. This could lead to confusion when two different modules contained shelves with the same name.
  • A throw or a run-time error from the body of an external-data-entity rule would lead to unpredictable run-time behavior.
  • string sink could not be used as a cast.
  • %c was not streaming properly when it appeared embedded in a larger string.
  • The with utf-8 argument to do sgml-parse was erroneously being evaluated after the input to the parse had begun executing. This contrary to earlier versions of OmniMark, where it was evaluated before the input. The proper order of evaluation has been restored (i.e., with utf-8 is evaluated before the input).
  • The with utf-8 modifier was being ignored when using the subdocument option of sgml-parse.
  • If the prefix binary operator or the complement operator were used in a shelf reference context, an internal error would be triggered.
  • An internal error was triggered if an expression containing operator new applied to a stream shelf was passed as a shelf-class argument to a function.
  • The with id-checking parameterization was being allowed when launching the well-formed XML parser. This is contrary to the specification.
  • Conflicting definitions for dynamic and/or overriding functions could lead to misleading error messages.
  • An invalid invocation of do markup-parse could trigger a segmentation fault at compile-time.
  • The error message emitted when the void action was applied to an invalid type was misleading.
  • The error message emitted when applying save or save-clear to a string source or string sink was confusing.
  • A catch could not be declared following the declaration of a record type exported as opaque.
  • The built-in shelf #xmlns-names is now declared as a string shelf, rather than as a stream shelf. This change can be reflected in certain error messages.
  • The OmniMark compiler could take an amount of time exponential to the number of mutually-referencing record types.
  • If the only use of a single-item, fixed size shelf was in the header of a repeat over with an alias, no warning was emitted about it being otherwise unused.
  • An invalid memory read was triggered if an else clause appeared in a do select-type block containing an invalid type name as one of its cases.
  • If a value-returning function failed to return a value from the else clause of a do ... done block, the line number reported in the error message would point to the last action of the previous block.
  • A string sink identity cast (i.e., casting a string sink expression in a context requiring an expression of type string sink) would lead to an internal error at compile-time.
  • If an exception occurred in a match clause of a do scan ... done block, the line number reported in the error message would point to the last action of the previous block.
  • It was possible to repeat over two shelves of differing sizes, if the larger shelf was declared variable. This is contrary to the specification and contrary to statements made in the documentation.
  • If a fixed-size shelf of size 0 was used in the header of a repeat over where a pseudo-shelf or a variable-size shelf was also present (e.g., attributes), an invalid error message was triggered, claiming that the shelves have different sizes, even when the pseudo-shelf was also empty.
  • A numeric literal was allowed in a pattern. This is contrary to the specification, and is no longer allowed.
  • A program that shadowed the and infix operator by a user declaration, and then used it between two string sinks, would no longer compile. Such a program is valid and should be accepted.
  • An optional value string sink function argument could not have an initial clause containing a conditional operator.
  • An inaccurate error message was emitted when an overriding of a dynamic function was dispatching on an exported type, but not itself exported.
  • The -depend command-line option now includes external function library information in its dependency graph.
  • The first argument in the invocation of a parenthesised, overloaded function was not being correctly parsed by the OmniMark compiler. This would lead to a syntax error. A workaround was to insert additional parentheses around the argument.
  • void on a string source expression could lead to inefficient execution.
  • Appending modifiers to a read-only stream in a string sink context could lead to segmentation fault.
  • Appending modifiers to a string value in a string sink context could lead to segmentation fault.
  • Hiding the keywords variable and/or size with a shelf declaration could lead to a confusing error message.
  • Under exceptional circumstances, it was possible for a program's string literals to get corrupted.
  • initial as a function argument herald was not being handled properly in various contexts. This would lead to the rejection of correct programs.
  • The error message emitted for conflicting argument counts contained a grammatical error.
  • Using argument pass-through with an optional string sink argument initialized to a stream would lead to a segmentation fault at run-time.
  • An xmlns-change rule in a multi-module program, where the main module ends with a function, could cause all rules in other modules not to fire.
  • Throwing an exception from the header of an external-text-entity rule would lead to a segmentation fault.
  • In certain circumstances, external-text-entity rules and external-data-entity rules could lead to unpredictable behavior in later parts of the program.
  • A throw or a run-time error from the body of an external-data-entity rule would lead to unpredictable run-time behavior.
  • The compile-time error message triggered on mismatched catch clause arguments was confusing.
  • Passing a read-only stream to a function expecting a value string sink argument would lead to a confusing error message.
  • An internal error was triggered when a value switch argument was aliased in a repeat over loop. A workaround was to drop the alias and use the argument name directly.
  • The compile-time message emitted when a read-only stream was used in the header of a using output as did not make sense.
  • If counter was used as a type herald, the error message thereby triggered referred to integer as the type.
  • If int32 was used as a type herald, the error message thereby triggered referred to integer as the type.
  • Using take on a string source on the right-hand side of a matches could lead to the string source being entirely consumed.
  • Referencing #current-input or #current-output in a using shelf item association would trigger an internal error at compile-time.
  • #current-output was accessible in the body of a markup sink function. This is contrary to the specification.
  • A markup sink function was being rejected on the left-hand side of set.
  • A warning is now emitted when a shelf literal is being used where a simple expression would suffice.
  • Spurious warnings were emitted when record types were being assigned.
  • A join in a find rule could trigger an incorrect compile-time warning, and could also negatively impact performance.
  • A repeated (||*) in a pattern was not being compiled properly; this would lead to inefficient execution at run-time.
  • A warning is now emitted when the g format item is encountered alone in a string; the use of the g format item in this way is redundant, and should be eliminated.
  • The error message triggered for an undeclared string in a g format item referenced the wrong line in the program.
  • An incorrect error was being emitted when the require qualifier was encountered in a shared module.
  • A keyword could not be used as a module prefix.
  • The set new action on a record shelf was not constructing intermediate values.

Fixed in the OmniMark 9.0.0 run-time

  • The body of an external-text-entity rule in OmniMark 8 was run in a coroutine whose parent was the current element rule, in contrast to the correct input domain parent coroutine in earlier versions of OmniMark. The behavior has been corrected.
  • The effects of sgml-in and sgml-out were being incorrectly propagated to XML parses launched as children of a parent SGML parse.
  • Whitespace was being dropped when a well-formed XML parse was launched as a child of a validating XML parse.
  • If a consumer coroutine suspended using the output action before trying to consume its input, it could be left suspended in that position. This caused problems if the suspension preceded a catch clause that was supposed to handle signals coming through its input.
  • A segmentation fault could occur if a string was returned from a function, and the string was a run-time constant (e.g., the name of an external string sink attachment).
  • The values of #markup-error-count and #markup-warning-count were not local to the current parse in case of multiple co-routining parses.
  • A confusing error message was emitted when attempting to copy a shelf with a variable size to one with a fixed size, and the two sizes did not match.
  • A throw from a string source function used by a do xml-parse could cause a memory leak.
  • Leaving a stream attached to a referent unclosed by the end of the referent scope could lead to a segmentation fault.
  • In a scenario where multiple OmniMark threads are running in OMWSB, a markup error in one thread could corrupt the state of other threads, leading to an internal error or unpredictable behavior.
  • The presence of a markup-error rule could cause the subsequent markup error reports to leave out the exact error locations.
  • Under certain circumstances, the status of last subelement is inclusion test could return an incorrect result.
  • A log directive in a markup-error rule launched from one parse could affect the logging of a different markup-error rule.
  • In some circumstances, referents could not be written to a stream attached to a referent, even though referents had been enabled.
  • A value written to a stream attached to a referent that had previously been assigned a value with referents-allowed, was being appended to the previously-assigned value rather than replacing it.
  • name of #suppress would lead to an internal error at run-time.
  • #suppress has name would lead to an internal error at run-time.
  • After the consumption of #current-input in a string sink function was interrupted by a signal, it could not be resumed if the take operator was being used.
  • If no element rule was fired, OmniMark would report an error message with no file name and line number.
  • In certain contexts, a guarded new could lead to a run-time error about accessing a non-existent shelf item.
  • A markup error in the input could cause an internal error if multiple OMWSB services were running in parallel.
  • A well-formed XML parse would allow the carriage return character (%13#) to propagate to the output: this is contrary to the XML specification.
  • A signal sent to multiple coroutine sinks (combined into a single sink by the & operator) at the same time stopped its propagation as soon as one of the target coroutines suspended to any coroutine other than the signalling one.
  • Executing output-to at the top-level of a string source function called as the argument to file would lead to a segmentation fault at run-time.
  • If any content modifers were set, but a %c was run in a separate coroutine, the modifiers were ignored.
  • Referring to an undeclared notation in a DTD scanned by the well-formed XML parser would trigger an internal error.
  • translate patterns erroneously matched a content-end when content was interrupted by a processing instruction, comment, or marked section.
  • A signal thrown from a markup rule could cause an internal error.
  • Artifacts of markup parsing were not being updated properly when using an external markup parser.
  • An internal error was triggered if a string sink function with referents-allowed was passed to a second function as a value string sink argument, and the latter function terminated without yielding to its argument. Typically, this meant the argument was not accessed in the body of the second function.
  • Multiple, nested joins would lead to a segmentation fault at run-time.
  • It was possible to trigger an internal error by outputting referents into a string sink function that parses its #current-input.
  • An internal error was triggered when a throw occurred in a markup-error rule and a processing instruction was being parsed by the well-formed XML parser.
  • If any markup-comment rules were present in a program, the text of every markup comment that did not trigger any of the rules would be submitted to translate rules, when it should have been suppressed instead.
  • After processing the content of an element which contains a nested element of the same name, references to the attributes of the outer element may return incorrect values.

Fixed in the OmniMark 9.0.0 markup parser

  • An incorrect error message was emitted when an invalid owner identifier in the public identifier of a notation declaration was encountered.
  • The well-formed XML parser was incorrectly accepting -- in comments; this is contrary to the specification.
  • An error message referring to an SGML document was emitted by the validating XML parser if an XML document did not contain a valid DTD.
  • The validating XML parser did not properly handle hexadecimal character references with leading zeroes.
  • The well-formed XML parser was rejecting parameter entity references in the DTD if they were not properly nested with markup declarations. According to the XML standard, this is a validity constraint, not a well-formed constraint.
  • An undeclared notation was triggering a markup error in a well-formed XML parse; this is contrary to the specification.
  • Invalid character references were being accepted by the well-formed XML parser. It now implements the restrictions dictated by the XML 1.1 specification.
  • Referring to an undeclared notation in a DTD scanned by the well-formed XML parser would trigger an internal error.
  • In a scenario where multiple OmniMark threads are running in OMWSB, a markup error in one thread could corrupt the state of other threads, leading to an internal error or unpredictable behavior.
  • The well-formed XML parser would incorrectly trigger a markup error if more input was required while reading the doctype keyword.

Fixed in the OmniMark 9.0.0 libraries

  • The OMCGI library function cgiGetQuery could fail with a program error for certain inputs.
  • The external OMRTF parser would segmentation fault.
  • The OMVFS library triggered a compiler warning about uninitialized data access.
  • The function HttpRequestSetFromUrl in the OMHTTP library did not correctly parse a URL if the query string component contained an @ sign.
  • A source filter's output could be terminated too early if its argument produced a zero-sized chunk.

What was fixed in OmniMark 8.2.0

Fixed in the grammar for OmniMark 8.2.0

  • A comment in the grammar for string sink literal erroneously referred to the production for [void function call], where the production for [value function call] was meant.

Fixed in the OmniMark 8.2.0 compiler

  • In certain contexts, hash-quoted names were not being handled properly. In particular, a hash-quoted name with an embedded null character would be truncated, thereby making it inaccessible.
  • A misleading error message was given when attempting to define a conversion-function from numeric-literal to string.
  • The error message emitted when an invalid format item was encountered in a function definition was needlessly confusing.
  • A recursive conversion-function was being silently accepted. A compile-time warning is now generated where a conversion-function may recurse.
  • The error message emitted when attempting to require a record type was misleading, implying that record types cannot be exported.
  • An initialiser was required when declaring a constant shelf of size 0; this is no longer needed.
  • A shelf literal appearing in the header of a rule caused an internal error at run-time.
  • A function containing a %c in a branch of a conditional operator could not be called in a context where %c is unavailable. (This should be legal, so long as the %c is never executed.)
  • A pretentious module (that is, a module compiled as a main program) could lead to a cascade of incorrect error messages. In some cases, a subsequent error could trigger an internal error in the OmniMark compiler.
  • An incorrect line number was given in the error message emitted when a dynamic initialiser in a shelf declaration would throw.
  • element names were referred to as GIs in certain error messages.
  • Reference comparisons could not be applied to instances of invisible type.
  • A confusing error message was emitted when a sub-expression requires parenthesisation.
  • The compiler allowed #current-output at the outermost scope of a string sink function.
  • this referent could not be used as a string sink in contexts where this use is unambiguous (e.g., using output as this referent).
  • An incorrect value would be printed for optional function arguments when the -ftrace command-line option was used.
  • Attempting to pass a string source to a function accepting an argument of class read-only would trigger an internal error.
  • The -ftrace option could lead to an internal error in programs using catch/throw.
  • A misleading error message was emitted when a string shelf item appeared in a position where a character class was expected.
  • An internal error would be triggered if referent or file <filename> appeared in one of the branches of the conditional operator, which in turn appeared in a string sink context.
  • open ... as applied to a string sink function predeclared with elsewhere would cause an internal error.
  • A misleading error message was emitted when attempting to define an overriding of a dynamic function for a type that is not visible.
  • A compile-time error was being triggered when attempting to access the item number of referents, indexed by item number, i.e.,
       output "d" % item of referents[1] || "%n"
    
  • In certain error messages, a catch was being referred to as a function.
  • An internal error would result when using operator new on a switch in an expression context.
  • In some situations, if the arguments to a numeric comparison were specified as string literals, the incorrect result would be yielded at compile-time.
  • translate rules did not flush the content captured by the implicit translate rule early enough. That could cause the content captured by a translate rule to be mixed up with the content preceding the rule.
  • The compiler allowed an else clause on a do select-type block when the head type had already been handled in a case clause. This is contrary to the specification, since the else clause is dead code, and should be removed. An error is now emitted.
  • The append modifier could not be used in conjuction with the new operator on the left-hand side of the open action.
  • A misleading error message was emitted when an invalid identifier was encountered in an argument position.
  • A type disambiguation was incorrectly required when a shelf literal appeared on the right-hand side of set.
  • Error messages related to the declare data-letters declaration referred to it as the (deprecated) letters declaration.
  • And internal error would be triggered on an invalid declare name-letters declaration.
  • An invalid shared as name in an interface module would lead to a segmentation fault when the corresponding implementation module was imported.
  • A shelf literal in a character class would trigger an internal error.
  • The compiler would get stuck in an infinite loop if a compile-time error occurred when the error threshold was crossed, and the original program had triggered compile-time warnings.
  • In certain contexts, the type of the right-hand argument of an infix operator was not being determined properly.
  • The error message emitted when an ellipsis was missing from a function definition was needlessly precise.
  • A duplicate warning message was being emitted when the overloading argument of an overloaded function was declared as either value source or value output.
  • A warning is emitted when the current elements pseudo-shelf is accessed in a context where it is guaranteed to be empty.
  • The error message emitted when an element test appeared in an invalid context was misleading.
  • An overloaded switch function could not be used in a find rule.
  • Attempting to pass a value string source argument to a function taking a read-only string argument would trigger an internal error.
  • The error message emitted when an argument was declared with an improper class was incorrect.
  • Following a compile-time error, errors about missing returns in function bodies were not being emitted.
  • A segmentation fault would occur when declaring a pre-declared record type that extended another pre-declared record type.
  • Defining a function as non-overloaded when it was previously-defined as overloaded would lead to an incorrect error message.
  • Action next group is in a find rule did not affect the find-end rules' active group.
  • In certain contexts, hash-quoted names were not being handled properly. In particular, a hash-quoted name with an embedded null character would be truncated, thereby making it inaccessible.
  • A conversion-function from string source to switch could not be invoked: an error was emitted claiming that a type cycle had been created.
  • A cast could not appear as the first component of a pattern.
  • A string source cast on #current-input was causing the input to be buffered. This was both unnecessary and incorrect.
  • In certain contexts the new operator applied to strings and streams would lead to an internal error in the OmniMark compiler.
  • A shelf literal appearing in a strong context occasionally required a type disambiguation.
  • The doctype is test inside a repeat over loop could lead to a segmentation fault.
  • An unnecessarily cryptic error message was given when the pattern occurrence operator was applied to something other than a pattern.
  • Warning codes were not being emitted in warning messages.
  • Attempting to use a function's value argument as a shelf-class argument (i.e., read-only, modifiable, or write-only) to a catch would trigger an internal error.
  • A function elsewhered, never defined, and called in a using input as qualifier, would lead to an internal error at run-time.
  • An internal error would be triggered if a stream test was applied to a value stream argument.
  • string source modifiers (e.g., binary-mode, buffered, ...) were not always being propagated to external string source functions.
  • An unspecified optional argument could be used in a context where its value was required but unknown, leading to undefined results. This is now a run-time error.
  • A syntax error while generating a call to a function taking a value string sink argument would lead to a segmentation fault in the compiler.
  • Passing an stream indexed numerically to a function as optional string sink argument could corrupt the optionality of other arguments.
  • In elsewhered function definitions, the OmniMark compiler rejected #main-input and #process-input as initialisers on optional string source function arguments, as well as #main-output, #error, #suppress, and #process-output as initializers on optional string sink function arguments.
  • A compile-time warning is now emitted when #main-output or #process-input is encountered in contexts where it might lead OmniMark to wait indefinitely for input.
  • #current-input and #current-output are no longer accessible in record type constructors.
  • In some contexts, calling a dynamic function on an undeclared shelf could lead to an internal error.
  • A shelf of type string could not be copyed to a shelf of type stream. This operation is well-defined and should be allowed.
  • A run-time error in an else clause of a do...done block pointed to an incorrect line number.

Fixed in the OmniMark 8.2.0 runtime

  • The error message issued when a wrong type of file is given to -load command-line option now indicates so.
  • For certain program errors, OmniMark would lose portions of the message if the exception was caught.
  • name of on supplied external string sink functions did not always return the correct name.
  • The test is thrown did not succeed for exceptions that have been thrown and will be handled by the current catch scope, nor for exceptions thrown by other coroutines.
  • If an external exception was thrown from a catch clause, the program could continue running.
  • insertion-break and replacement-break rules were not properly module-protected. Now they fire in the module where the stream was opened.
  • The error message issued for format items such as "%4ki" and "%6ka" was wrong.
  • Content processing with "%c" could not be delegated to a child coroutine.
  • The error message issued for invalid format items like "%12g" was unhelpful.
  • external-text-entity rules in one module was turning off default entity resolution in other modules.
  • A segmentation fault would result when using the repeated (||*) operator on a string longer than 4096 characters.
  • Non-printable characters in string values are now escaped in run-time error messages.
  • Pattern-matching a long pattern variable belonging to the string source being matched could erroneously fail.
  • The content-start pattern was sometimes erroneously succeeding at a point following an entity.
  • Values of pattern variables assigned from patterns containing other pattern variable assignments could get corrupted.
  • If a notation referenced in a DTD is not defined, the error message reported the last entity instead of the entity that was using the notation.
  • An internal error was triggered if "%epq" was used inside a repeat over #libpath, inside an external-text-entity rule.
  • A stream previously opened as a buffer without referents-allowed and then reopened with referents-allowed no longer buffers the previous contents of the buffer. This should result in a small performance improvement.
  • A parse of a string source function on the left-hand side of drop or take operator was causing a crash.
  • reopen with referents-allowed without as clause was failing if the stream did not already have referents allowed.
  • A terminating string sink function passed as a value string sink argument could cause an internal error, or a section of code to be not executed.
  • output-to a string sink function with an empty body, predeclared with elsewhere, could cause an internal error at run-time.
  • A call to a predeclared external string sink function could crash at run time.
  • The value-start pattern didn't match on the beginning of a source created using drop operator.
  • A call to a predeclared string source function that was eventually resolved to an external string souce exported from a module was not correctly generated: incorrect data was generated from the call.
  • Messages with embedded null characters were truncated when emitted by assert or not-reached.
  • Pattern-matching a long, generated string could erroneously fail.
  • An internal error was occurring in some complex cases when multiple exceptions were being thrown and caught.
  • A throw from a translate rule header could cause a segmentation fault.
  • A halt-everything in markup-error rule would cause a segmentation fault at run time.
  • A function call inside a scope feeding a string source function could raise an internal error.
  • A find-start rule could affect the element rules' active group.
  • Run-time errors that list many conflicting rules could cause a segmentation fault.
  • An unspecified argument passed through as an optional argument to an external function was treated as specified.
  • An externally-defined function could not manipulate an argument of class write-only.
  • A string sink function passed as an argument to an external function did not receive any input until the external function closed it.
  • External functions with value string sink arguments could not be passed a multi-component sink, constructed using operator '&'.
  • The precedence of modifier lists was incorrect. This could cause modifier expressions passed as arguments to user-define infix functions to be parsed incorrectly. In some cases, an internal error in the OmniMark compiler would be triggered.
  • The test #current-output in an always clause could lead to a segmentation fault if the current output was a coroutine that executed halt.
  • A string source function with another string source function passed as argument was being bypassed when called in the context of a do xml-parse or do sgml-parse.
  • A string source that was consumed as a part of a join could sometimes be scanned again outside of the join.
  • If a join of multiple string sources was scanned and then restored to its starting position, the join's components' positions were not restored.
  • Markup errors and warnings were reporting entities as though they were files.
  • OmniMark engines and VMs were reporting run-time warnings with command-line option -warning specified, but no total warning count.
  • The VM executables allowed #main-input and #process-input string sources to be used together even when there were no input files specified.
  • Repeated uses of log-message could unnecessarily consume large amounts of memory.

Fixed in the OmniMark 8.2.0 markup-parser

  • The grammar of the error message emitted for a misspelled end tag was incorrect.

Fixed in the OmniMark 8.2.0 libraries and external API

  • The functions in the modules OMBESSEL and OMTRIG could not be used with numeric literals.
  • OMWSB services now log to the same log stream used by the server.
  • The ODBC back-end of OMDB could raise an error or trim significant digits off numeric field values that were near the top of their range.
  • External library functions that were taking a modifiable stream argument have been generalized to take a write-only string argument.
  • The OMXERCES library would leak a small amount of memory in exceptional circumstances.
  • The OMVFS function vfs.connect-directory was expecting a "file:" protocol specification. It now works on plain file system paths.
  • An environment variable whose value was an empty string was not being picked up in OMUTIL.
  • The OMVFS library function vfs.copy was failing to copy symbolically linked directories on Unix platforms.
  • The OMVFS library function vfs.describe did not report proper results for a Unix file when its owner or group identifier did not correspond to a known user or group.
  • The C++ API has been extended with function OM_PersistentSource_t::AtEnd () that provides access to the low-level C API call OMXF_SourceAtEnd ().
  • The functions provided by the module OMTCP now all throw on errors.
  • A memory leak occurred if an exception was triggered in an external function taking an argument of type string or stream, and of shelf class (i.e., read-only, write-only, or modifiable).
  • A memory leak occurred if an exception was triggered in an external function taking an argument of type opaque, and of shelf class (i.e., read-only, write-only, or modifiable).
  • When using the OMXSLT library, the memory allocated for a stylesheet would be leaked if an error was encountered while parsing the stylesheet.
  • An error message related to a use of an external string sink would refer to it as a persistent source, rather than persistent sink.
  • OMDB library functions db.insert, db.update, and db.delete that operate on tables now can handle table and field names with non-alphanumeric characters.

Fixed in OmniMark 8.2.0 Studio

  • The global referents entry in the variable table now appears only if the program uses referents.
  • Programs written using aided translation types, such as cross-translate, could be run but not debugged in Studio for Eclipse.
  • A throw from within a using nested-referents scope would terminate the current debugging session in OmniMark Studio.
  • The -ftrace option was missing from the OmniMark Studio debugger.
  • The #external-text-entity #document rule was not working in the OmniMark Studio debugger.
  • A throw collapsing an #external-test-entity rule could terminate the current OmniMark Studio debugging session.
  • A throw from a function argument initializer could terminate the current debugging session in OmniMark Studio.
  • A dynamic initializer on a global or constant shelf could stop the Studio debugger.
  • An invalid-data rule could cause the OmniMark Studio debugger to prematurely quit execution.
  • The documentation plug-in for OmniMark Studio for Eclipse did not work in Eclipse 3.3.

What's fixed in OmniMark 8.1.0

  • When a cascade of multiple markup parses feeding each other was terminated, an error could occur.
  • The -help command-line option text did not specify the arguments for the -gc-threshold and -gc-increment options.
  • A shelf literal appearing in the header of a rule caused an internal error at run-time. This is now a compile-time error.
  • The SGML #appinfo information was accessible from an XML parse nested in an SGML parse.
  • A run-time error (e.g., inaccessible file) occuring inside a referent scope could lead to an internal error in OmniMark, or a segmentation fault.
  • An output to #current-output from a function called within a fork (i.e., the & operator) could go to another stream specified by the fork.
  • The parsing of using output as (and similar constructs) with multiple destinations could be confused by extra parentheses around the first stream.
  • The using attribute scope containing "%c" could cause an internal error in some cases.
  • The output of a string source function used on the right-hand side of a scanned join operator (i.e., ||) was sometimes discarded.
  • An always clause could stop exception propagation.
  • Using the submit action in a pattern matching context (e.g., do scan), prefixed by a using output as would lead to an internal error.
  • A submit of a string source derived from the output of a parse could cause a segmentation fault.
  • A program that uses line-breaking rules would leak a small amount of memory.
  • Attempting to use a string source as a string sink would lead to an internal error in certain circumstances.
  • The behavior of coroutine termination depended on whether the scope that launched the coroutine was left normally or thrown out of.
  • The prefix binary operator could not be overloaded.
  • The infix operators difference, format, mask, modulo, shift, and union could not be stropped (i.e., escaped using the backtick)
  • A process-end rule in an implementation module would cause an internal error.
  • A warning is now emitted if a document-start, docuement-end, find-start, or find-end rule is encountered in a module; these rules cannot be triggered within a module.
  • A warning is now emitted when the is keyed shelf query is applied to a keyless shelf; this test is invariant and should be removed.
  • When using the -ftrace command-line option, the compiler could report that a valid function definition was invalid.
  • Outputting to the #markup-parser sink from an element rule would cause an internal error instead of throwing to #program-error.
  • A newline declaration was allowed in a program that contained modules, if it appeared after the module import(s). This is not well-defined, and is contrary to the specification. An error message is now generated.
  • Stream modifiers specified on the attachment of open or reopen did not have any effect.
  • The buffer attachment type did not allow modifiers to be specified.
  • Usage of disallowed modifiers on value string sink arguments was not reported at compile-time, and could lead to a segmentation fault at run-time.
  • The compiler was not reporting the usage of open-only modifiers, like text-mode, in other contexts like using output as.
  • When reopen...as was applied to a stream that cannot be reopened, an invalid error was reported.
  • Trying to use a shelf literal of type string sink or string source would lead to an internal error.
  • The new operator appearing where a string sink was expected could cause a segmentation fault. This is now a compile-time error.
  • A failing ++ operator sometimes did not restore the input consumed.
  • The string sink functions from external filter libraries (e.g., omffbase64) would close persistent string sinks (such as #main-output) that were passed to them.
  • An internal string sink function passed as an argument to an external function would not see the data written into it by the external function.
  • Duplicate environment variables were not being handled properly by OmniMark.
  • The test #current-output has name caused an internal error instead of a proper compile-time error.
  • Passing #current-output as a write-only argument could cause an internal error instead of a proper compile-time error.
  • A list of modifiers with an open parenthesis did not require a matching closing parenthesis.
  • A string coercion could cause an internal error in certain contexts.
  • The precedence of the arguments for user-defined infix functions was too low.
  • An incorrect result was generated when a shelf item query was applied to an indexed shelf item (e.g., item of applied to a shelf indexed by item).
  • The pattern expression lookahead not not would lead to an internal error, rather than a syntax error in certain circumstances.
  • Using the named sub-pattern anywhere but in the header of a translate rule or in the header of a processing-instruction rule would lead to an internal error.
  • A second return (from an always clause) from a string source or string sink function caused an error.
  • An invalid argument type in a catch declaration would lead to an internal error in a catch clause.
  • A small memory leak occurred whenever an external string source function was lazily consumed.
  • The compiler did not report an error for two constant shelves declared with the same name, but with different types.
  • The error message emitted when a duplicate shelf declaration was encountered could be misleading.
  • A global shelf of a record type could be used in its initializer. This is no longer allowed, since the shelf has not been created when the initializer runs.
  • The error message emitted when attempting to save a constant specified the wrong type.
  • The shelf use warnings emitted for shelves of record types were not consistent with those for shelves of other types.
  • The help text on some command-line options was incorrect.
  • Exceptions were not being handled properly by using nested-referents scopes.
  • The line numbers reported with referent-resolution errors were incorrect.
  • The leading herald in a catch invocation could be left out. This is contrary to the specification: the herald is now required.
  • Attempting to use a string sink function in a using shelf item association would trigger a misleading error message.
  • An internal error would be triggered if a value string source argument appeared in a using shelf item association.
  • The compiler erroneously accepted a value string sink argument in a using shelf item association.
  • The error message given when an incorrect save groups was encountered was incorrect.
  • A number of memory management issues in omdb_sedna have been fixed.
  • Outputting from a string source function to its #current-output and a string sink function in parallel could cause an internal error.
  • submit within a using input scope in a find rule could trigger an internal error in the compiler.
  • Use of a dynamic element test in presence of multiple coroutines could cause the same test to fail when applied in a different coroutine.

What's fixed in OmniMark 8.0.1

  • The non-validating built-in XML parser could cause a crash on parameter entity declarations in some circumstances.
  • Compiling a module as though it were a main program could crash a compiler.
  • The -f command-line option on Unix did not accept OmniMark project files (.xop) produced on Windows.
  • Using an explicit switch cast would cause an internal error.
  • The #current-input is attached test returned a wrong value in some circumstances.
  • In some situations, the compiler would segfault when recursively invoking an overloaded dynamic function.
  • The compiler would segfault when defining a function with the same name as a previously-defined type.
  • It was possible to satisfy the requirements of an interface module from an unrelated module.
  • The code generated for the is specified test on optional arguments to a function was incorrect under certain circumstances.
  • When a string source coroutine was output through an intermediary, context switches did not occur until the coroutine was finished.
  • An incorrect error message was emitted when an initial clause was specified on an optional argument of class other than value.
  • Using operator newon a shelf literal heralded by an undeclared type would trigger an internal error or a segfault in the compiler.
  • The compiler allowed using output as to be applied to the result of operator new.
  • The compiler would not report an error on name collisions between catch arguments.
  • The OmniMark interpreter could lose track of specified attributes in a well-formed XML parse. This could lead to run-time errors when trying to access attributes.
  • Non-ASCII characters were not properly handled by the command-line parser. This could also have affected Studio.
  • A throw from an optional function argument initializer was catchable in the function body. This behavior has been modified: argument initializers are outside the function scope.
  • A throw from a function called by a record field initializer was not catchable and would terminate the program.
  • The compiler did not flag an error on encountering #current-input in several contexts where #current-input would be unattached at run-time. This moves an error from run-time to compile-time.
  • The compiler erroneously allowed access to #current-input in a string source function. This error used to be caught at run-time; it is now caught at compile-time.
  • A throw from a translate rule that consumed all its input could cause a segmentation fault.
  • Casting a non-existant variable name to sink would cause an internal error.
  • A compiler internal error could be caused by specifying an incorrect file name for an interface module in some circumstances.
  • The compiler would incorrectly accept the syntax export as opaque catch.
  • The function capture-environment in the library OMUTIL was not displaying error messages in failure cases.
  • A string-returning function called from a pattern could consume #current-input and affect the continued pattern matching. The patterns are now protected from side-effects on #current-input.
  • OmniMark VM for Java could not use the omutil library.
  • OmniMark VM for ActiveX could not use the omutil library.
  • OmniMark ActiveX component is now automatically registered during the installation.
  • A warning is emitted if the old pattern-variable style syntax is used to access the parameters of a markup-error or sgml-error rule: this style is deprecated, and its support will be removed in a future version of OmniMark.
  • In the case where the result type of a function required by a module and the result type supplied to it did not match, the resulting error message misnamed the two functions.
  • A warning is now reported when #console is encountered; #console is deprecated.
  • If an external function exported from a module had an optional argument with an initializer, and that function was called from a different module were a pre-declaration for the function existed, the argument's initializer was not being generated.
  • Operators drop, matches and take did not try to invoke conversion functions on their first argument.
  • The error message emitted when a disallowed declaration was encountered was incorrect.
  • An internal error was triggered when the operator item of was applied to a shelf indexed by item.
  • New error messages have been documented in the error documentation.
  • Reading of large buffers from external functions has been optimized.
  • A pattern of the form any{"%d(i)"}, where i is an integer, was being rejected.
  • The error message emitted when a pattern-save operator appeared inside a repeated pattern has been improved.
  • The error message for patterns like 'any ++ 5' would advise defining a pattern conversion-function, which is not allowed.
  • The -help command-line option text did not specify the arguments for -gc-threshold and -gc-increment options.
  • The compiler did not detect dead code appearing after a return action in a function body.
  • A warning is now emitted when a shared module uses the same share name as an apparently different module.
  • The restriction that #current-input from a string sink function cannot be used as a value string source function argument has been removed.
  • The AIX version of Concurrent Processing Engine was checking the total CPU count, instead of the active CPU count.

What's fixed in the libraries of OmniMark 8.0.1

  • It was not possible to sort a shelf of streams if one item on the shelf was unattached.
  • Services were not always shut down by the Web Services Broker.
  • Performance improvements were made to the load monitoring algorithm in the Web Services Broker.

What's fixed in OmniMark 8

  • The warning "pattern can match zero characters" was being emitted spuriously for patterns using the ++ operator.
  • The pattern any* would consume only up to 2 GB of data. This limitation has been removed.
  • A repeat over loop inside of a catch clause would scramble the information required to rethrow the exception.
  • The with append modifier had no effect when assigning to a referent.
  • Two functions overloaded on related modifiable record types would collide. This restriction has been removed.
  • A memory leak when performing a well-formed XML parse could cause OmniMark to exhaust available memory under certain circumstances.
  • A memory leak when allocating and freeing shelf items has been fixed.
  • Certain patterns could cause the OmniMark run-time pattern stack to become unbalanced, which would lead to an internal error.
  • A problem with the is default-entity test caused it to always evaluate to false.
  • A segmentation fault would occur when using the keyword opaque as the data type of an argument of a catch or a function. The problem would not be manifest if a user-defined data type named opaque was declared.
  • Assigning a value to a switch shelf item using an item indexer was not being handled properly, which could lead to erroneous behavior at run-time.
  • It was possible to corrupt the run-time stacks of the OmniMark interpreter using recursive function calls. This would lead to an internal error.
  • .An internal error was being triggered on the pattern any* when true.
  • A memory leak would occur if a throw happened in a find-start rule for a cross-translate program.
  • Trying to use the lastmost indexer on a shelf-class function argument could lead to a segmentation fault in the OmniMark interpreter.
  • The % (format) operator was not being handled properly in a pattern context.
  • The referents shelf now supports the new indexer syntax.
  • Successive pattern matches and any** were not being evaluated correctly.
  • The conditional operator (->) did not handle user-defined types properly.
  • An internal error occurred when using a sequence of any** (or any++).
  • An internal error was produced on number of sgml-dtds.
  • A segmentation fault occurred when using scan input #main-input in an XML parse.
  • The time required to scan a large buffer is now proportional to the size of the buffer, rather than being proportional to the square of the size of the buffer.
  • The behavior of the -ftrace command-line option has been changed: instead of writing its output to the #error stream, it is written to log-message, allowing this feature to be used in server environments where no-default-iomight be in effect.
  • An internal error would be emitted if a throw occurred inside a repeat over current elements.
  • A duplicate record declaration now states where the first declaration occurred.
  • In some circumstances, it was possible for a monolithic module to export an unsatisfied (elsewhered) definition, which was satisfied in the importer. This has been disabled.
  • It was possible for a repeat over current elements loop to change the name of the current element obtained via the name of element expression.
  • A last content is appearing outside of a parse would cause the OmniMark run-time to segfault.
  • Attempting to use operator new as the read-only argument to a function would cause an internal error.
  • Catch parameters would not shadow shelves with the same name, leading to correct programs being rejected.
  • A number of error messages have been corrected or expanded. This affects the text of the messages only: error codes are not affected. In particular, the quality and specificity of the error messages output for function definitions are improved; however, other messages were revisited as well.
  • An incorrect error message was being issued for clear sgml-dtds{""}.
  • An incorrect error message was being issued for is specified applied to a shelf with a key-based indexer.
  • The error message output when a type error occurred for the name of operator has been improved.
  • The error message emitted when the name of operator is applied to a value stream argument has been improved.
  • An incorrect error message would be emitted when trying to define a function argument of type remainder source.
  • A shelf subjected to the has name test was not being flagged as used, and therefore a spurious warning was being emitted.
  • translate rules were firing within the scope of markup-comment rules if they wrote to #error.
  • An invalid warning was being emitted for the rule
            find any ++ => p lookahead ("Hello, World!" | =|)
    
  • The import order of shared modules was significant, in particular when one module exported a record type that the other extended.
  • A dynamic function had to be declared as overloaded as well, if an overriding was declared in a different module.
  • An error in the OmniMark parser was allowing the construct referent "..." to be used wherever a stream shelf reference was required.
  • A syntax error in a module could lead the OmniMark parser to crash with a segmentation fault.
  • #current-input was not inherited from the invoking domain to the input domain when invoking a markup-parser.
  • A syntatically-invalid dynamicfunction declaration could cause an internal error in the OmniMark parser.
  • The introduction of the operator form of new has led to a number of issues being fixed in its implementation.
  • An internal error would be emitted when a down-translate was begun on a truncated input.
  • A repeat over on an empty constant or global shelf would cause an internal error.
  • The performance of the ** pattern operator has been improved.
  • A shelf item's key could not be set to itself:
           process
              local stream s initial { "Hello, World!" with key "Salut, Monde!" }
      
              set key of s{"Salut, Monde!"} to "Salut, Monde!"
    
  • Code generation of the conditional operator was not being handled correctly.
  • The keyword value was not being handled correctly when used as a function argument herald.
  • Code generation for modules has been streamlined.
  • The assignment of a stream-returning function to a stream shelf has been optimized.
  • An interaction between referents and records would cause a crash at execution time.
  • An internal error would occur during execution if the initializer for a shelf threw an exception.
  • Parentheses were required when using activate or deactivate on an expression involving cast.
  • An internal error would be emitted if the argument to a dynamic function involved the cast operator.
  • The is specified test was not being evaluated correctly in a well-formed parse.
  • An XML parse inside an SGML parse would incorrectly inherit the case-insensitivity of the SGML parse.
  • If a coroutine threw two exceptions simultaneously, an internal error would occur at execution time.
  • The precedence of an output function was being ignored in certain contexts.
  • It is now possible to initiate a markup parse from an input function. This allows the output of one markup parse to feed the input of another
  • An internal error when using a field of a result of a record-returning function has been fixed.
  • Overloadings of built-in infix-function names, such as and, couldn't be exported from modules.
  • Key-based access to record field shelves used to evaluate the key before the record expression. The order of evaluation has been reversed.
  • Some internal errors triggered by nested heralded function calls have been fixed.
  • The non-overridden dynamic functions were not properly inherited in some cases.
  • Unparethesized field access in a function call argument caused an internal error.
  • Erroneous overloaded dynamic function definitions on non-record types caused an internal error. A regular compile-time error is reported now.
  • The conditional operator didn't properly check if the optional function arguments in its test expression were specified.
  • Fetching the item of a built-in stream shelf like #current-output caused an internal error.
  • The compiler did not report the location of any unsatisfied elsewhere function definition.
  • The with append modifier in some situations didn't work properly on buffers.
  • The repeat over action didn't check if the shelf was an unspecified optional function argument.
  • The field access didn't check if the record was an unspecified optional function argument.
  • The copy action didn't check if either of the shelves was an unspecified optional function argument.
  • A markup error in a DTD include file referenced by a DTD public identifier could cause another error when attempting to obtain the entity name of the include.
  • Exceptions were not handled properly in code blocks containing scanning actions followed by catch and always.
  • The #current-input appearing after an action containing the drop operator referenced the result of the drop instead of the contextual current input.
  • The old-style programs using aided translation types were sometimes buffering the whole #main-input in memory.
  • Attempting to use the (non-existant) key of a scalar constant shelf would cause a segmentation fault in the compiler.
  • Use of conditional operator on the left hand side of field access could cause an internal error in compiler.
  • Operator new applied to a stream shelf literal would cause an internal error in the compiler.
  • A problem with the handling of modules by the OmniMark compiler was causing syntactically-valid, parenthesized macros to be rejected.
  • The OmniMark compiler would crash when attempting to overloaded the built-in format function using a different signature.
  • The OmniMark compiler would crash if an incorrect herald was used in an external source function call.
  • A repeat over or using of a value string argument, using a shelf reference alias, was not being handled properly by the OmniMark compiler.
  • Under certain conditions, it was possible for the OmniMark compiler to leak the memory allocated for groups.
  • Trying to declare a record with a name already in use could lead to a segmentation fault in the compiler.
  • Declaring a record after it had already been used could lead to an internal error in the OmniMark compiler.

What's fixed in the libraries of OmniMark 8

OCI backend

  • Performing a query which returned multiple rows where one of the columns is of type LOB no longer throws an exception on the second and subsequent rows when trying to read the LOB
  • Calling the db.discard function on a compiled statement used for a streaming insert no longer causes a crash
  • Very large numbers in some Oracle numeric datatypes could have been truncated when being queried

ODBC backend

  • Performing a streaming insert into MS Access LONG fields now works
  • Retrieving datetime fields from MS SQL Server now retrieves the 'seconds' component instead of just returning '00'
  • Retrieving datetime fields from MS Access no longer throws an exception
  • Performing an absolute negative move-record of > 10000 rows in a result set containing more than 10000 rows now works.

What's fixed in OmniMark 7.1.2

  • There was an error in Studio for Eclipse when compiling and saving byte code files. This has been fixed.
  • A problem with the interaction between the omxerces library and OmniMark's handling of XML namespaces has been fixed. XML namespaces are now handled correctly when a markup-parse is being performed using the omxerces library and XML schema validation is active.
  • A segmentation fault was encountered when closing an active stream; this has been eliminated.
  • A segmentation fault encountered when parsing shelf-reference valued functions has been eliminated.
  • An error in the parsing of remainder arguments with a herald of and has been fixed; these are now handled correctly.
  • Built-in operators in the guard of an insertion-break or replacement-break were erroneously being rejected; this has been fixed.
  • Infix-functions were being allowed in the guard of an insertion-break or replacement-break; this has been fixed.
  • An internal error would occur when submitting #current-output following a drop expression on something other than #current-output; this has been corrected.
  • Certain operations on an unopened mail box in certain conditions could cause the ommail library to hang; this has been corrected.
  • OmniMark client programs created with omtcp using 7.1 or 7.1.1 and run on an IPV6 configured machine may fail to connect to servers which are not IPV6 enabled. This includes OmniMark servers running OmniMark versions lower than 7.1.
  • A problem that could cause hangs in OmniMark networking calls has been fixed. This had been particularly apparent using end-delimited TCP/IP protocol.
  • Error messages have been updated to refer to the markup stream as #markup-parser, rather than the deprecated #sgml.
  • omutil.xmd and omutil.xin calls util.get-millisecond-time and UTIL_GetMilliSecondTimer respectively could fail on Windows with a message "Invalid integer argument". This has been fixed.
  • A problem involving a conflict between the number of initial values for a shelf and the specified size of the shelf has been fixed. This was reflected both in an incorrect error message and in the initialization of opaque-typed shelves.
  • The support for initial values of optional arguments has been corrected to reflect the specification.
  • An incorrect error message was generated when the initial value of an optional argument to a function differed between the as definition and an elsewhere definition. This has been fixed.
  • The implementation of exported functions from modules has been fixed to disallow exporting an elsewhere definition for a function without also exporting an as definition for the same function.
  • A problem involving element context tests appearing in the guard of input domain rules has been fixed.
  • Error messages have been updated to refer to the command-line arguments shelf as #args, rather than the deprecated #command-line-names.
  • Compile-time error recovery for dynamic functions has been improved.
  • Dynamic functions can now be predeclared using an elsewhere declaration.
  • An error message involving extended record types and conversion functions has been clarified.
  • Support for keyword argument heralds has been improved.
  • The parser now recovers more quickly when a module is given as a main program.
  • Overloaded action functions can now appear following a using prefix.
  • A dynamic function can now dispatch on the result of a function call.
  • A character class can now follow a shelf name in a pattern.
  • An error involving exporting a shelf without its type has been fixed.

What's fixed in OmniMark 7.1

  • An internal error for some complex, nested, non-parenthesized function calls has been fixed
  • A segmentation fault for exceptions thrown from external-text-entity rules has been fixed
  • An internal error for a statically false take pattern has been fixed
  • Variable shelves with initial-size 1 were not settable from the command line. Now they are.
  • The compiler didn't allow value-returning functions to be ended by "not-reached".
  • The "binary-mode" couldn't be applied to some external source functions.
  • The "%g" format item didn't work on pattern variables.
  • An internal error for faulty calls of external functions with output arguments has been fixed.
  • The compiler accepted "using output as " with more than one same stream destination. It no longer does so.
  • The copy-clear action didn't clear the default shelf item and the stream name. Now it does.
  • Attribute declaration tests weren't properly implemented.
  • An internal error for "has name" applied to a value argument has been fixed.
  • Operator precedence was wrong in some contexts.
  • Multiple importation of functions from shared modules could cause name collisions.
  • An internal error for deep nested function calls with shelf arguments has been fixed.
  • An internal error for xmlns-change rules in modules has been fixed.
  • Inconsistent shelf declarations are now caught at compile-time.
  • An internal error for throws from within "do sgml-parse" has been fixed.
  • Some combinations of "take" and "drop" operators could cause pattern variable data corruption. This has been fixed.
  • A crash that occurred when closing ftp connection in omftp has been fixed.
  • A memory leak in omftp when read or write fails has been fixed.
  • A crash when closing pop3 mailbox in ommail has been fixed.
  • 'describe[-file]' functions in omvfs sometimes threw an exception in Windows due to being unable to access PDC to resolve user/group names. This has been fixed.
  • 'describe[-file]' functions in omvfs were returning times in an incorrect format in timezones > GMT. This has been fixed.
  • ombcd and omfloat module header files couldn't both be imported unprefixed. This has been fixed.

What's fixed in OmniMark 7.0.2

  • An error where #base rules for an element were not being selected if the element was mentioned without the "base" modifier in a query has been fixed.
  • An internal error triggered when the source used in a do...parse construct contains "#current-input drop [pattern]" has been fixed.
  • Throws from the outer scope of a markup-error rule were not catchable in the body of that markup-error rule. This has been corrected.
  • repeat for integer foo ... now allows int32 to be used in place of integer.
  • drop used in a global variable initializer expression no longer causes an internal error.
  • The current output destination was being corrupted when a markup parse was being aborted before it could start, for example when the file being parsed did not exist. This has been fixed.
  • An error where a legitimate compile-time error would be followed by an internal error has been fixed.
  • Using back-quotes to get the keyword interpretation of a symbol was not working for action keywords overriden by non value-returning functions.
  • A "++" pattern with a terminate pattern that can never fail was causing an internal error. This has been fixed. Note that due to the semantics of "++" these sorts of patterns can never succeed anyway.
  • An internal error triggered by certain function call sequences mixing parenthesized and unparenthesized function argument lists has been fixed.
  • Throwing local variables as read-only arguments to a catch that is outside the scope of that variable's declaration was causing OmniMark to crash. This has been fixed.
  • Library rules in programs using modules were not useable. This has been fixed.
  • The following fixes have been made to the Xerces parser interface:
    • The "external-text-entity" rule has been enhanced:
      • The entity name is now available (using the "%q" format item).
      • Where an external text entity is the external declaration subset of a DTD, its name is #DTD, and it is recognized separately from named entities.
      • Where an external text entity is an externally provided XML Schema, its name is #SCHEMA, and it's again recognized separately from named entities, and separately from a #DTD entity.
    • Declaration information from the DTD is now used in the same manner as when using OmniMark's native markup parsers.
    • Empty element recognition has been improved:
      • Empty tags (those ending in "/>") are now recognized.
      • The "content is empty" test is true when either an element is declared empty (in a DTD or Schema) or has an empty tag.
      • The new content is declared-empty is only true when an element is declared empty.
      • The new content is empty-tag is only true when an element has an empty tag.
    • There's more information available for an element's attributes when there's a DTD or Schema to provide the information:
      • All attributes, specified, defaulted or implied are now returned, and the "is specified", "is defaulted" and "is implied" tests distinguish between them.
      • ) The various attribute types—CDATA, ID, IDREF, IDREFS, ENTITY, ENTITIES, NMTOKEN, NMTOKENS, NOTATION and name token group (a.k.a. GROUP) -- are recognized, and the existing OmniMark tests distingish between them.
      • You can "repeat over" an attribute. For IDREFS, ENTITIES and NMTOKENS attributes there's one iteration per ID name or entity name.
      • For ENTITY attributes and for the individual tokens of ENTITIES attributes, the "is public" and "is system" tests work, you can ask for the "notation of attribute", and the "p", "e" and "o" modifiers of the "v" format item provide the same information as with OmniMark's native markup parsers.
      • For NOTATION attributes, the "is public" and "is system" tests work, and the "p" and "e" modifiers of the "v" format item provide the same information as with OmniMark's native markup parsers.
  • The LDAP library, OMLDAP, has been substantially rewritten to improve stability and correct various errors.

What's fixed in OmniMark Studio 7.0.1

  • Studio now opens Windows registry keys with appropriate permissions. This fixes an error whereby Studio would not be able to read the authorization key when run by users having only read access to the registry key in question.
  • Studio now correctly reads in external library paths when loading a project.

What's fixed in OmniMark 7

  • TCPConnectionGetOutput and TCPConnectionGetSource now set return values properly when applied to a TCPConnection that is in error or not connected.
  • An error has been fixed that caused tcp-accept-connection in the omtcp library to crash or enter an infinite loop when receiving many requests quickly.
  • The omfloat library now handles math errors consistently on all platforms.
  • The ombcd library had a memory handling error that may have caused unexpected behavior when freeing some bcd values. This has been fixed.
  • On Windows, describe now works on read-only devices, such as CD-Roms.
  • On Unix platforms, make-directory now gives new directories the correct access permissions.
  • On Unix platforms, describe now takes Daylight Savings Time into account when reporting file access times.
  • Memory leaks and crashes related to memory handling in the omldap library have been fixed.
  • An error has been fixed that caused omldap functions to crash when operations were performed after the connection was closed.
  • ldapOpen will now allow port numbers up to 65535.
  • ldapCreateAttribute, ldapAttributeGetValue, ldapAttributeGetValues and ldapModifyEntry now check the datatype parameter.
  • An error in MailInBoxGetMessage caused extra null bytes in lines that were longer than 512 characters.
  • Quoted names (such as "foo") have been removed from the few places where they were still accepted.
  • Syntax error messages now correctly report the cause of the syntax error. This error occurred infrequently.
  • The external function tcp-accept-connection (or TCPServiceAcceptConnection) no longer crashes OmniMark or sends it into an infinite loop if the connection is broken before the function returns.
  • In releases of OmniMark prior to Version 7.0, when a "do sgml-parse" action was used with the "with utf-8" option set to "true", where the parsed document contained an SGML Declaration (i.e. "<!SGML ...") prior to the DTD, and a numeric character reference, OmniMark incorrectly returned the low-order 8 bits of the character's number. This has now been fixed tso that the UTF-8 encoding is returned.

What's fixed in OmniMark Studio 7

  • When Studio automatically loads a file during a debugging session, the include paths are now correctly considered.
  • An infrequently-occurring buffer reading error has been fixed. This would happen while Studio was reading data from an edit window during a debugging session.

What was fixed in OmniMark 6.5

  • The reconnect sub-function of external output functions is now being called when the output stream is reopened.
  • Quoted variable names were being allowed in some contexts. They are now prohibited in all contexts.
  • ++ expressions with one or more pattern variables in the terminate pattern no longer cause an internal error.
  • The date operator no longer outputs occasional spurious characters when using the am/pm indicator (=a or =A) in the format string.
  • An internal error relating to saving global variables that are being used as modifiable function arguments has been fixed.
  • Throwing using local variables as the read-only arguments of the throw, and then catching that throw outside the scope of the local variables no longer causes OmniMark to crash.
  • Some errors and instabilities in the omldap library have been repaired
  • The omsysout library now throws the correct exception when failing to start a program on UNIX.
  • The ommail library no longer inserts null characters in lines longer than 512 bytes.
  • In the omvfs library , these errors have been corrected:
    • vfsDescribe no longer fails on Windows when the target is on a read-only filesystem (such as a CD-ROM)
    • vfsDescribe now properly handles daylight savings time.
    • vfsMakeDir no longer ignores the user's umask on UNIX, and no longer sets more restrictive permissions than requested.
  • In the omtcp library, clients connecting and disconnecting quickly will no longer cause a crash or an infinite loop.
  • In the ombcd library, in one rare failure case, a crash would occur on some platforms while ombcd tried to throw an exception. This has been repaired.
  • In the omfloat library, theses errors have been fixed:
    • The definition of round has been fixed to use "nearest" instead of "by"
    • round now handles half-way cases properly (e.g. 3.5 -> 4)
    • ceil, trunc and floor have been fixed to handle exceptional cases.
    • The outputting of NaN is now platform-independent
    • The outputting of scientific format floats is now platform-independent.

What was fixed in OmniMark Studio 6.5

  • When OmniMark Studio automatically loads a file during a debugging session, the include paths are now correctly used.
  • An infrequently occurring buffer reading error has been fixed. This would happen while Studio was reading data from an edit window during a debugging session.
  • Block operations are now enabled and disabled correctly according to whether or not the active edit buffer is writeable.
  • In some situations, a pattern variable would appear twice in the local variables table. This no longer happens.
  • Studio now permits debugging runs on the day its authorization is set to expire.

What was fixed in OmniMark 6.1.3b

Desktop Engine and Server Engine on the Windows platforms again correctly handles reading standard input from the command line. This fixes an error introduced in 6.1.3a.

What was fixed in OmniMark 6.1.3a

Desktop Engine and Server Engine on the Windows platforms now correctly handle reading from standard input, when running as a CGI under IIS5.

What was fixed in OmniMark 6.1.3

  • The file...is writable test works correctly for non-existant files in a writable directory.
  • vfsLock no longer causes a file to be unreadable by the process using the vfsLock function.
  • Rethrow from value-returning functions is now accepted by the compiler.
  • always blocks now execute after uncaught external exceptions.
  • The date operator now returns the correct timezone on Windows.
  • An intermittent internal error, that has been present since 6.0, caused by an uninitialized variable, has been fixed.

What was fixed in OmniMark Studio for Eclipse 6.1.3

  • OmniMark Studio for Eclipse now correctly identifies carriage returns as valid line-end markers.
  • The Find/Replace dialog box is now correctly initialized when invoked without text selected in the active edit buffer.
  • A markup parse with a parsing datascope visible no longer causes a memory violation when the parse terminates.
  • The variables tables now correctly handle the case of optional, non-integer shelves in function calls, which previously caused off-by -one errors in their display.
  • Exiting OmniMark Studio for Eclipse while running a program now displays a warning that the debugging session will be terminated, and offers the user a chance to cancel the operation.
  • Whitespace characters are now handled correctly when copying text out of the log window, the shelf details window or the referent details window.
  • The syntax colorization algorithm now correctly handles the case of a string-end marker preceded by multiple escape characters. For instance, the string "%%%" is now colored as an unterminated string.
  • OmniMark Studio for Eclipse now properly frees dynamic library resources between runs.

What was fixed in OmniMark 6.1.2

The following problems have been fixed in version 6.1.2

  • A memory leak relating to the use of dynamically-formed keys for shelves was closed. Now you can create shelves dynamically without leaking memory, either by issuing code such as
      new my-shelf {"d" % i}
    
    or by issuing
      set new my-shelf {"d" %i} to "fred"
    
  • There is no longer a duplicate error message produced when throws generated by external functions are not caught by the calling program.

What was fixed in OmniMark 6.1.1

  • Using dynamically-formed keys for shelves no longer causes a memory leak (a defect introduced in 6.0.2).
  • In the omoci library (Oracle Call Interface database support), database and cursor handles are now closed correctly. They were not being closed until the end of the OmniMark run, causing some programs to run out of handles.

What was fixed in OmniMark Studio for Eclipse 6.1.1

Studio once again reads large program and data files correctly. A defect introduced in version 6.1 caused Studio to occasionally read large programs and data files incorrectly when they were loaded into edit buffers.

What was fixed in OmniMark 6.1

The following problems have been fixed in version 6.1

  • When using rethrow, rethrowing an external-exception will now be consistent with rethrows of all other types of exceptions.
  • In user-written external function libraries, the entire OMX API is now available to the creator subfunction.
  • The repeated operator (||*) now does proper range checking for negative numbers in all cases.
  • An internal error related to empty patterns and pattern assignment while doing a repeat scan has been fixed.

What was fixed in OmniMark Studio for Eclipse 6.1

Problems have been fixed so that OmniMark Studio for Eclipse

  • Displays data more rapidly in all datascopes (such as the Parsing Sources datascope and the Scanning Sources datascope)
  • Processes all characters correctly, including those whose value is greater than 127. (Previously, if your OmniMark program accessed files that were open in an edit buffer and those files contained such characters, the results were unpredictable)

For further information, see the OmniMark Studio for Eclipse Windows help file.

What was fixed in OmniMark 6.0.2

The following problems have been fixed in version 6.0.2

  • Element rules immediately preceded by catch declarations are now always being selected during an XML parse.
  • integer and counter are useable interchangeably as casting operators for user-defined conversions function casts.
  • Casting user-defined OMX types using converstion-functions no longer result in internal error 1039-115.
  • using #group will now save the group set for restoration.
  • When doing #current-input matches... certain patterns will not cause characters to be consumed from #current-input even when the matches failed.
  • Error checking in the library omtcp-old (a deprecated TCP/IP client and server support library) interface has been cleaned up.
  • OmniMark external function API which adds support for making external function libraries thread-safe has been updated.
  • OmniMark error messages have been enhanced for when unable to bind an external function or load an external function library.

What was fixed in OmniMark 6.0.1

The following problems have been fixed in version 6.0.1

core language

  • -stats now gives timing statistics again.
  • Earlier versions erroneously allowed some functions and variables to share a name. Such name sharing will now trigger an error.
  • Release subfunctions that trigger external exceptions were getting invoked a second time. This behavior has been corrected.
  • Characters that fell through during a submit were enabling empty patterns to fire twice consecutively rather than once only.
  • Problems with internal errors and corrupted values for complex dynamic initializers have been fixed.
  • An internal error with occurrence count ranges used on a string constant has been fixed.
  • An internal error triggered by "++=>" being used in a take expression has been fixed.
  • Key based default item indexing didn't detect the disappearance of the default item key, and so allowed access to a default item that should no longer have been accessible. This behavior has been corrected.
  • Strings being converted to numbers at run time were producing wrong values when the strings contained "_" characters. This behavior has been corrected.
  • Numeric literals were erroneously being accepted wherever stream values were expected. Such a condition will now trigger an error.

omvfs library

  • The function vfsMove now works across devices on UNIX platforms.
  • Microsoft Windows drive letters now work with omvfs functions.

omdb library

  • Case sensitivity of table fields has been removed.
  • The function dbProcedureExecute now checks for the presence of a result set, and dbProcedureOpen does not.
  • Before dbRecordMove is executed, it will check whether the dbField argument shelf is empty, and whether it's positioned on a valid row,
  • The trailing zeros in the numeric fields that were returned by Oracle have been removed.

What was fixed in OmniMark 6.0

The following problems have been fixed in version 6.0. This list includes fixes to problems discovered in public betas of OmniMark 6:

  • The copy-clear produced a run-time error when used on a modifiable shelf function argument.
  • The null pattern modifier did not work correctly with repeat scan.
  • The ++ and ** occurrence indicators were causing the ul pattern modifier to extend beyond its proper scope.
  • using input as was not behaving correctly inside a match body of a do scan #current-input.
  • Cascading numeric comparisons of strings and numbers (for example 1 < "2" < 98) were causing an internal error.
  • do when with a catch block was erroneously falling through from the catch block to the else clause.
  • Consecutive occurrence indicators that should have been flagged as an error were being allowed.
  • The expression name of #main-output was causing a syntax error.
  • In rare circumstances, patterns would sometimes fail to match.
  • Full string expression syntax was not supported inside curly brace indexers.
  • If a new shelf action failed because of key collision, an unspecified shelf item was incorrectly created.
  • Sub-pattern variable assignment in a pattern which failed caused an internal error.
  • Pattern variable assignment in a repeatedly executed null find rule caused an internal error.
  • Repeated use of the pcdata character type in a pattern failed to match correctly.
  • Positional patterns were incorrectly restricted from occurring in patterns. As a consequence of this correction, positional patterns are now allowed in more pattern-matching contexts.
  • Outer pattern variables became corrupted in nested #current-input scans.
  • In some cases, an uncaught #external-exception did not result in a throw to #program-error.
  • The ul pattern operator scope was incorrectly extended to the end of the pattern.
  • Throws from the sub-functions of OMXs, external sources, and external output objects failed.
  • The matching position of #current-input was incorrectly restored when exiting or throwing out of a repeat scan.
  • The ommail library has had an error that duplicated periods that occurred in the mail message.
  • Variable type-heralds are no longer allowed. They were allowed in some places; this was an error. Some programs may need fixing when ported to this version of OmniMark. This error was introduced with OmniMark 5.3.
  • An interaction among #current-input, submit, and pattern variables was causing incorrect behavior.
  • The pattern word-end was being handled incorrectly. This was introduced with OmniMark 5.3.
  • Functions that contain only catch blocks were being handled incorrectly. This error was introduced with OmniMark 5.3.
  • The test
         do when <string-expression> matches ...
    
    was not supported. This error was introduced with OmniMark 5.3.
  • Start-tags containing more than 180 element attributes were causing a memory allocation error.
  • An interaction between reopen, keys, filenames, and function-calls was causing incorrect behavior.

OmniMark 5.3

The following have been fixed in version 5.3.

catch now works in processing-instruction rules.

Trying to output a catch now triggers an error message, not a segmentation fault.

When using the halt statement, the return value generated by the presence of markup errors was taking precedence over the programmer-defined return value. The halt value now always takes precedence over markup errors.

OmniMark 5.2

The following errors are corrected in OmniMark 5.2:

You can now flush streams in Windows.

Including duplicate entity definitions after multiple doctypes no longer triggers an internal error.

An extra carriage return is no longer emitted to standard out/standard error in Windows.

Throwing from sgml-parse no longer triggers an internal error.

The construct ul (pattern => var)+ no longer triggers an internal error.

#sgml-error-total and #markup-error-total are no longer reset to 0 in document-end rules.

When #current-input is not yet attached, the code output #current-input now gives a run-time error message instead of a segmentation fault.

rethrow #program-error now works.

When no element rule can fire for an element name and no element #implied rule is used, a run-time error message is given instead of a segmentation fault.

Compiling DTDs works properly again.

Attempting the is attached test on a remainder shelf no longer gives an internal error.

In Linux, OmniMark no longer gives a segmentation fault when it finds a syntax error of the form when parent is (x or ).

Opaque remainder shelves with exactly two items no longer trigger an internal error.

Trying to call an external output function that takes a remainder argument no longer triggers an internal error.

When a stream is reopened with referents-allowed, length of now returns the correct value, not twice the correct value.

Using nested saves no longer triggers an internal error.

A syntax error in a copy action no longer triggers an internal error.

Extra output no longer occurs in an up-translation of xml-parse/sgml-parse.

Dynamically converting from a string to a number now allows a leading "+" in the string.

The pattern ul [char-set] now ignores case.

System identifiers in external entities and doctypes may be the empty string. In previous versions, this triggered an internal error.

OmniMark now gives a run-time error instead of a segmentation fault if the program tries to compile a DTD to a shelf with the key currently in use.

OmniMark no longer gives a segmentation fault when trying to use a nonexistent DTD key.

using group <group-name> and #implied now triggers a compiler error. This change could break programs that currently work.

An interaction between translate rules, nested parse actions, and entities has been fixed.

File output using the options -log or -alog is now unbuffered.

OmniMark 5.1.1

The following have been fixed in version 5.1.1.

OmniMark 5.1 had an error in the operation of do scan, repeat scan, and submit. When a match statement or a find rule started with value-start and the string matched was greater than 108 characters, the match failed when it shouldn't have.

OmniMark 5.1

The following corrections have been made in OmniMark 5.1:

  • OmniMark no longer triggers a segmentation fault when it finds the letter "l" in place of the or bar character ("|") in source code.
  • Optional, unspecified function arguments used inside catch or always blocks sometimes had spurious values. Accessing them should trigger a #program-error exception. This fix may change programs that ran, albeit incorrectly, under the May 1999 release of OmniMark 5.
  • The #current-input construct may no longer be used in conjunction with join or repeated. This might break existing OmniMark 5 programs that took advantage of this.
  • The -ftrace option is fixed, and once again counts returns from functions.
  • The OmniMark 5 error involving repeating over current elements or attributes in a find rule is fixed.
  • Doing submit #main-input from a markup rule no longer allows unmatched text to be subject to line breaking. This fix can change the behavior of programs written to take advantage of this error, which was introduced in the May 1999 release of OmniMark 5.

OmniMark 5

The following OmniMark errors have been corrected in OmniMark 5:

Using the statement:

      Set function-library of external-function asf to ""
made any subsequent call to external function asf cause a fatal error, and an operating system call message would be displayed.

The Date and Time library had several problems:

  • the arpadate-to-ymdhms function matched single or double digit hours, minutes, and seconds, but when it wrote them out made them all two digits long
  • erroneous input in the arpadate-to-ymdhms function could cause out-of-range program errors
  • non-digit input in the arpadate-to-ymdhms function could cause program conversion errors
  • the add-to-ymdhms function didn't handle negative month values correctly
  • the add-to-ymdhms function a month addition would sometimes produce an invalid day of the month
  • arpadate-to-ymdhms didn't always return a fully valid date and didn't handle a time part of 24:00:00 properly
  • day-count-to-ymd didn't handle February in a leap year in a clean manner

On Digital UNIX (OSF), internal error 14-683 arose because binary conversion was limited to 1 to 4 character strings, even though counters on that platform could be up to 8 bytes long.

When an SGML document was submitted to do sgml-parse and it had a comment in the instance not ended in the document entity, OmniMark reported an internal error.

The code

  ...
  do sgml-parse document scan input f()
  ...
first gave the correct error message that the input function wasn't internal, but then hit internal error 87-2265: define external function f () as "f".

A do sgml-parse instance, using a previously saved DTD, could cause an OmniMark internal error if another DTS was encountered within the instance.

As a result of error recovery in a bad mixed content model, customer-supplied documents could cause the SGML parser to go into an infinite loop, emitting record-end characters.

The erroneous pattern

  find ('href="' [^'"']* uc [^'"']* '"') => link
caused an infinite loop, and produced the message "Expecting start of a pattern, but received '^'".

On HttpRequestSend, the response could have a returned status of "200 - OK" even if the connection failed.

Internal error 116-4875 arose when you used put #sgml in an input function, wrote something to #error, and used an sgml-error rule elsewhere.

For code:

   output file "dir" || "/" || "Filename"
trying to read the file "dir", a directory, triggered an "interpreter read abort".

Jackhammer reported a segmentation fault when trying to handle empty files or data files with a header but no body.

The mail library would hang when reading certain messages from the InMailBox.

When messages were marked for deletion, MailInBoxGetMessage would deny you access to the other, non-marked messages.

When using no-default-io and sgml-error rules, an error reported that #main-output was unavailable.

OCI_odespp incorrectly handles the defsup, mode, and radix arguments.

For opaque arguments (modifiable and read-only), OmniMark didn't detect that you had specified the wrong opaque type.

Opaque expressions could not be parenthesized.

When trying an output-to on a local stream that had more than one item, a segmentation fault resulted when the stream was closed.

When trying to output to a modifiable stream parameter using item number indexing, you still output to the default item.

Improvements needed to pattern-matching performance when patterns started with dynamic strings. For example, the find rule in the following code would incorrectly attempt to match "a":

  global stream s
  
  find "b%g(s)"  ; s is open
    output "B"
  
  process
    submit "abc%n"

External functions didn't process read-only variables when followed by remainder arguments. The read-only shelf appeared, usually incorrectly, to have the same number of arguments as the following remainder shelf.

Entering the command line omnimark -s prog.xom -s prog.xom produced the message: "The instruction at 0x... referenced memory at 0x... The memory could not be written."

When OmniMark couldn't open a file for writing, and quit with an error message, a segmentation fault resulted when it tried to close the unopened file.

The #sgml stream allowed translation and line breaking, but shouldn't.

When sgml-error was false, an internal error was produced in the debugger.

The sgml-in and sgml-out actions were not allowed in functions or inside do sgml-parse blocks.

If a non-text entity reference occurs within a text entity referenced from within RCDATA element content, the SGML parser erroneously reports that an entity referenced prior to the start of the RCDATA element is ended within the element's content.

When a non-SGML character occurred in CDATA element content, and it occurred immediately following a non-stripped record-end character (that is, one not at the start or end of the element), the OmniMark's SGML parser didn't recognize it and reported an "impossible" error. This error, in turn, caused OmniMark itself to terminate abnormally (for example, a segmentation error).

Garbled syntax error messages were generated by code:

  set integer j to item of attributes lastmost

The message was: Syntax Error. Expecting "The keyword 'ATTRIBUTES' cannot be used with the 'LASTMOST' indexer", but received "SET".

Testing to see if file "" existed triggered a non-recoverable error message.

On VAX/VMS, accessing a nonexistent directory caused an access violation.

When compiling with -warnings, a warning appeared that a stream opened only as an external output stream might be used incorrectly, even when it was opened, written to, and closed.

An internal error message was generated when using -warnings and -limit, and the warning level was exceeded in the compiler. The following program triggered the message:

  process
  local integer i
  local integer j
  local integer k
  process
  output "hello%n"

Command line was:

  omnimark -s prog.xom -limit 2 -warning

Generated message was:

  omnimark --
  OmniMark Warning on line 5 in file tr5447b.xom:
  A shelf is possibly not being used as intended.
  The LOCAL integer 'K' is never initialized or used.
  
  omnimark --
  OmniMark Warning on line 5 in file tr5447b.xom:
  A shelf is possibly not being used as intended.
  The LOCAL integer 'J' is never initialized or used.
  
  There were 2 warnings detected.
  Internal Error.

In Windows NT, specifying -library followed by a non-conforming library file on the OmniMark 4.0 command line caused a memory fault.

On Windows 95/98/NT platforms, a memory error occurred when the following command line was issued: omnimark -term.

OmniMark sometimes terminated with a segmentation fault when parsing an XML document with more than one ATTLIST declaration for an element.

OmniMark 4.0.2

The following errors have been corrected in OmniMark CI 4.0.2:

  • Trying to access nonexistent directories on VAX/VMS systems causes an access violation.
  • Character sets in patterns that start with an unquoted "^" go into an infinite loop.
  • Invalid library files result in memory faults in Windows NT.
  • OmniMark does not detect mismatched opaque types for modifiable and read-only function arguments.
  • Opaque expressions cannot be parenthesized.
  • External functions do not process remainder arguments correctly when read-only arguments are also present.
  • When system-call is invoked and the process' "INTR" and "QUIT" signals are currently different, the difference is not restored when the system-call returns.
  • sgml-error and markup-error rules cannot be used in programs that include a no-default-io declaration.
  • The "-linger" command-line option is not properly invoked.
  • When using "-limit" and sgml-error, and there are warnings in the data, the warnings aren't reported (which is correct), but they are still counted towards the specified limit.
  • When there are no errors but the number of warnings exceeds the limit when using both the "-limit" and "-warnings" command-line options, an internal error is reported.
  • When attributes lastmost is used, an incorrect error message is reported.
  • On Digital UNIX systems, an "Internal Error 14-683", rather than a run-time error, is reported when a string is too long for binary conversion.

The following errors have been corrected in the OmniMark Kernel:

  • The SGML Kernel does not properly handle unfinished comments (for example, when a document ends before a comment is closed).
  • Error recovery in a deprecated mixed-content model goes into an infinite loop.

OmniMark 4.0.1

The following errors have been corrected in OmniMark CI 4.0.1:

  • The XML parser does not properly handle numeric character entity references between 256 and 2147483647, inclusive.
  • Certain tests that end with a constant value, such as do when f1 () f2 () and false, constant string values at the end of tests, such as do when f1 () and "a" = "b", and tests that contain only constants along with constant string values, such as do when i != 3 and "a" = "b" produce internal errors.
  • Using sgml-out <dynamic string value> causes a memory leak.
  • On VMS, doing a file test or trying to access a nonexistent external function or library will cause a stack trace.
  • Evaluation order of expressions containing "join", "format", and parenthesized string expressions is incorrect.
  • Stream names are given incorrectly in error messages when the stream is on both sides of a set new statement, as in set new s to s || ".txt".
  • If you have an sgml-error rule in a program in which no-default-io has been declared, when that sgml-error rule fires, the program will terminate immediately.

OmniMark 4

The following list of OmniMark errors found in V3R1a have been fixed in 4.0:

Memory Leaks

If an external function signals an exception in nested do sgml-parse's, memory is leaked.

Programs that contained both sgml-error rules and explicit references to the #sgml stream leak memory when the sgml-error rules are executed.

Writing single values larger than 8 Kb to the #sgml stream leaked memory.

Parsing documents that have a document element that has a CDATA attribute leaked memory.

Programs that write to the #sgml stream from an sgml-error rule leaked memory.

Programs that accessed data attributes leaked memory.

do sgml-parse

Specifying an unknown element in a do sgml-parse instance with document-element unknown-element caused OmniMark to crash.

In process programs, the state of the #sgml stream is attached after a non-nested do sgml-parse action was executed. It should be unattached.

Accessing the dtds shelf with a nonexistent key in a do sgml-parse instance with dtds key "unknown-key" causes OmniMark to crash.

The SGML stream isn't being flushed for find rules that contain embedded conditions such as find "&" (when number of current elements > 0). This means that the test can potentially fail when it should have succeeded.

Functions

The following code, which accesses an optional, unspecified function argument, does not report an access error in the second action:

  output x when x is specified
  output x

Passing a constant as a read-only function parameter causes OmniMark to crash.

Function argument heralds sharing the same prefix are not being properly distinguished. Consider this definition:

  define function foo sk1 read-only switch n1 optional
                       sk   value integer n2 optional
                       as
           ...
Now calling the function so:
  foo sk 1
The herald "sk" is mistaken for the herald "sk1".

Executing the submit action in a function invoked by an sgml-error rule causes an internal error.

The method OMXF_GetBinaryOrderingValue now returns the correct binary ordering.

Programs that try to match patterns of size > 2k when using external source functions fail.

Using the copy action to copy to a modifiable shelf argument corrupts the shelf.

The following code, where "arg" is an optional function argument, causes an internal error. In V3R0 the internal error is 86-440 and in V3R1a it is 86-335:

  output sample when sample is specified
  do when sample is specified
     output sample
  done

The following code, which creates and removes the same keyed item from a shelf with an initial -size of 0, causes OmniMark to crash:

       global stream s var initial-size 0
       process
          new s key "some"
          new s
          remove s
          new s key "some"

Miscellaneous

Copying one stream shelf to another changed the target shelf's name for some error messages.

OmniMark enters an infinite loop while writing to a file when the disk is full.

Assigning to a shelf with a declared size greater than 1 from the command line was not being reported as an error.

Stream items assigned multi-part values via a set action did not have the stream's name attached to the stream item. The internal stream #ANONYMOUS name was instead attached.

The test do when file x is writable applied to a file that does not exist, where the directory it names does exist and is writable, now correctly returns the value true.

The following incorrect code is incorrectly reported:

  process
    set #first to true

The error message now refers to switch #last instead of #first.

The test attributes has key x applied to an element that has no attributes causes OmniMark to crash.

Trying to match entity names with the following pattern when there are only lowercase letters causes OmniMark to report an "insufficient memory error" and then terminate:

  translate entity named (lc+ [lc or digit]+=>lower) => ent-name

Empty strings are incorrectly parsed in command-line argument files.

The expression do when file <my-file> matches <string expression> does not work.

An OmniMark program is limited to 8 MB of constant strings.

The rule translate entity valued any+ named any+ is declared to be an error.