What's 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.

Prerequisite Concepts    What was fixed    What was new    What's new    What's Changed

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