What's fixed

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, document-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 href="../keyword/1393.htm">#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.0

• 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 valuestream 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.
• Unparenthesized 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-existent) 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.