What was fixed

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 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.

[ INDEX ] [ CONCEPTS ] [ TASKS ] [ SYNTAX ] [ LIBRARIES ] [ LEGACY LIBRARIES ] [ ERRORS ]

OmniMark 9.1.0 Documentation Generated: September 2, 2010 at 1:35:14 pm
If you have any comments about this section of the documentation, please use this form.