elsewhere definition of an overriding function, without providing an implementation of the function. This is contrary to the specification. A compile-time error is now triggered.
-gc-threshold command-line argument was limited to 32-bit values. This is inappropriate on 64-bit platforms.
insertion-break declaration would lead to an illegible error message.
= form of the pattern capture operator was being given precedence in expression contexts such as drop and take. This prevented correct programs from compiling.
specified attributes shelf was not allowed in a process rule even when applied to an element event.
output is used at the top-level of a markup sink function, since this can fail at run-time.
do markup-parse block nested inside either a do sgml-parse or do xml-parse would corrupt the type of #current-dtd.
overloaded dynamic function on one type, without also exporting any other overloaded dynamic functions on other unrelated types.
!= and the type of the arguments was string or stream. This could cause programs to behave incorrectly.
name of operator was applied to the current elements pseudo-shelf.
copy or copy-clear had to have its type disambiguated. The type context of the right-hand side of copy or copy-clear is now determined by the left-hand side of the action.
is specified test was applied to the attributes shelf reference.
doctype is test.
has key was applied to an element qualifier in an element test. This is now a syntax error.
#content does not trigger the Attempting to process content twice in one rule error even if it consumes the entire rest of the content.
save declarations could, on rare occasions, produce corrupted outputs.
markup-element-event could cause an internal error or memory corruption.
output #content action could be used after output %c with no error. This is now flagged as a run-time error.
#content source twice in the same markup rule could cause a segmentation fault during the execution.
create-element-declaration an element declaration produced by parsing a DTD could lead to a segmentation fault at run-time.
-gc-keep-memory command-line option could cause a segmentation fault at the end of program execution.
accept header in HTTP requests.
MailInBoxGetMessage was occasionally ignoring the lines of the message body that started with the '+' character.
& can now be applied to two markup-buffer values.
omrelaxng library refused to compile a valid RELAX NG schema using a combine attribute on a start node only in the including schema.
l and u modifiers were being rejected on %eq. This was contrary to the specification.
import declaration, a non-sensical error message was emitted.
value argument was passed as a shelf-class argument to a shelf-class function, and the result of the function was used in a repeat over.
do select-type is missing the required alias.
new expression of type markup sink appeared as an argument of a string sink or markup sink function.
attribute alias in a repeat over attributes or repeat over specified attributes loop was being converted to a string value and back upon assignment to a shelf. This lead to the loss of the attribute's declaration in the target shelf.
optional argument initializers did not agree between a dynamic function and one of its overriding functions. The correct error message is now emitted
content was used on the left-hand side of a set, in a context where no shelf called content was previously-declared.
name of could not be declared dynamic.
overloaded infix-function with either argument declared to have type markup-element-event could not be invoked using an element expression in that position.
dynamic function.
do select-type.
new to an optional value function argument, inside an is specified test.
repeat over loop. This would lead to incorrect results at run-time.
%c or #content if it happened to be used as the argument of an overloaded function call. This could cause correct programs to fail to compile.
content appeared in a process rule, in certain contexts.
markup source function's signature did not match its declaration.
stream field of a record instance was used in a branch of a conditional operator, in the head of a using output as scope.
markup source function used by do markup-parse, the scope within do markup-parse terminated without a proper cleanup. This could lead to resource leaks, internal errors, or segfaults.
create-element-event an attribute shelf item with an empty string for a key would cause a segmentation fault at run-time.
attributes of create-element-event could lead to a segmentation fault at run-time.
create-unspecified-attribute multiple times could lead to an infinite loop.
declaration of attributes of create-element-event was not always correctly initialized. This could lead to a run-time error or segmentation fault.
#content after the first was interrupted could drop some data content.
create-specified-attribute to a specified-attribute and then accessing its value could cause an internal error at run-time.
do scan action from a markup-error rule could cause an internal error at run-time.
always clause to a coroutine function which called another function returning the same type of value, a program error could be issued even though there was no error.
join to a function that pattern matches ahead on the source could leave the source in an inconsistent state, potentially leading to corrupt output or a segmentation fault.
create-element-event only to fetch an attribute of the result could cause a segmentation fault.
#content was only partially consumed, the remaining unpaired #markup-end events would appear in reverse order.
close a stream attached to a referent by the end of the nested-referents scope the referent was bound to could lead to a segmentation fault at run-time.
#content, and then getting processed by a do markup-parse in a different markup sink coroutine, could cause an internal error and segmentation fault.
FTPConnectionRemoteOutputFile or FTPConnectionRemoteInputFile, the operations could fail with error OMFTP002.
netutil.host-ip function in the omnetutil library would return a useless value when querying for the address of the local host.
stream where one of type markup sink was expected. This is contrary to the specification, and is
no longer allowed.
signal to action inside a catch clause could cause
incorrect code generation, possibly leading to an internal error at run-time.
specified attributes pseudo-shelf.
key of operator was the
sole operation applied to a shelf that had been assigned a value.
with
document-element appeared out of sequence in a do sgml-parse or do xml-parse action.
read-only).
dynamic function definition whose export status did not match a previous elsewhere definition of
the same function.
string set
was left unclosed.
opaque type occurred in a branch of the conditional operator, in a context where a string
source or markup source was expected.
string
source function call with a shelf-class argument (e.g., read-only) was passed as a value
string source argument to an outer function call, and the argument of the inner function call was an
alias from do select or do select-type.
overloaded function was defined on a required record type.
dynamic function could be defined both with and
without an overloaded qualifier. This is not well-defined, and is no longer allowed.
specified-attribute was compared to a value of type integer.
attributes in the guard of a rule.
repeat over
loop could crash the compiler if one of the aliased shelves was a shelf literal.
repeat over. This is contrary to the specification. This had been an error in versions of OmniMark
previous to 10.0.0. The error has been re-instated.
new
was applied to an invalid value in the header of a using scope.
repeat over of a shelf with a fixed-size of zero could
lead to a cascade of incorrect compile-time errors.
#current-input in process rules, even though it was not attached and bound to fail at run-time.
is specified) to the
result of a function call could trigger an internal error at compile-time.
is keyed test was applied to the attributes shelf.
attributes
stream test.
markup-element-event inside a
module that didn't import other modules would cause a compile-time internal error.
sgml-in and sgml-out actions were erroneously
affecting the validating XML parser as well.
external-text-entity rule triggered by
do markup-parse could lead to an invalid memory access.
#current-dtd and #doctype are set to
incompatible values, and the subsequent program error thrown by #content was caught, it was possible
to trigger an internal error or incorrect behaviour.
#current-markup-event on an element with a
namespace-binding attribute was leaking memory.
attributes or specified attributes of
an element created by create-element-event could trigger an internal error or a segmentation fault
at run-time.
signal throw performed a throw back to the original coroutine through intermediates.
#content.
do markup-parse
#current-input inside a markup sink function could cause a memory leak or a segmentation fault.
do markup-parse to a markup source
containing external text entity references in some circumstances could lead to a segmentation fault.
#content would lead to a segmentation
fault if it included the end of an external text entity, but not its beginning.
repeat over attributes action could segfault on
an element that has both declared but unspecified, and undeclared but specified attributes.
create-element-event and create-element-declaration, could cause a segmentation fault when
processed by do markup-parse.
attributes shelf was passed to a function as a read-only argument.
#content twice inside a do markup-parse
scope lead to a segmentation fault.
create-element-event did not
have xmlns-name assigned even if its attributes specified one.
ATTLIST declaration was reported as a markup
error in validating XML parser, even though the XML specification allows it.
do markup-parse to a markup source function
with an argument that was another string source function followed by drop could cause an
internal error.
external-text-entity #document rule could in some rare
circumstances cause a segmentation fault in the interpreter during the loading time.
// or /./ character sequence could trigger a memory corruption or segmentation
fault.
execute function in the omprocess
library would not always allow the invoked process to consume all of its standard input, when used on
Windows platforms.
uri.canonical was properly working only on local URIs,
with no server.
uri.canonical was stripping the double-slash sequence
into a single slash even before the path segments. The result was an incorrect URI.
uri.canonical was normalizing the fragment portion of
the URI. The function now conforms to the standard and leaves the fragment unmodified.
maxOccurs integer attribute value.
external-text-entity rules for entities whose system identifier was an empty string.
domain-bound global is never saved.
export keyword was
incorrect.
#current-input and #current-output were not being tracked properly, allowing invalid programs to
compile. This is contrary to the specification, and has been
fixed.
record type could not be elsewhered
after it had been fully declared.
key of on a single-item unkeyed record field could lead to a segmentation fault at
run-time.
stream in the header of using output as.
value-start and value-end positional patterns were not
allowed in processing-instruction rule headers.
with current sgml-dtd was used with subdocument in do
sgml-parse.
new where only one is allowed.
optional argument in the
first position for a dynamic or overriding function. This is
not well-defined and is now rejected.
dynamic and overriding functions. This
is contrary to the specification, and is no longer
allowed.
save
a shelf literal was misleading.
save to a
built-in shelf was incorrect.
function imported from a module conflicted with a require.
copy from a fixed-size
shelf to a variable-size shelf, even when the former was larger than the
latter. This cannot succeed at run-time and must be
disallowed.
of, as for example
length of, were being rejected if they appeared as a function argument
and the following function argument was heralded by the second token of the
two-token keyword.
record declaration could
differ from that given in the elsewhere declaration. This is contrary
to the specification and is no longer allowed.
using input as "%c" was not always tracking the
use of %c, which could lead to correct programs not
compiling.
overloaded switch function with a
non-parenthesized argument list was not being accepted when compiling patterns
for take, drop, and matches.
previous is test in various
disallowed contexts were always reporting the content keyword as
being disallowed.
markup-comment and marked-section rules could
affect the boundaries of translate rules' pattern matching across the
module boundaries. This is now restricted only to the rules within the same
module.
remove action could fail when applied to a shelf item created by
using new inside the scope.
content-start and content-end patterns in translate rules
were not firing only at the beginning and end of element content, as they were
supposed to.
#content of an element with an XML
namespace change could trigger an internal error.
new could fail when the maximum shelf
size was reached, even when no new item was being added to the
shelf.
do markup-parse.
stream was opened, when in fact it was
closed.
#content was sometimes
incorrectly reported as a part of the SGML declaration.
markup-error rule.
external-text-entity rule and then
continuing to feed the parser could cause a segmentation fault.
do markup-parse command applied to a join of
xerces.xml external parser and another markup source could cause a
segmentation fault at run-time.
markup source after catching a throw could
erroneously lead to a markup event being thrown in a wrong coroutine.
previous is test always failed on the top-level element, and
its occurrence was always one.
previous is test could return random results inside a do
markup-parse consuming events from parses that were not active any more.
throw from an external string
source function was not being propagated if the function was called in the
setup of a pattern matching environment.
uri.parse did not accept a URI that contained nothing but
the URI fragment.
markup-buffer was written to through multiple sinks, the order of
the written string data was determined by the order in which the sinks were
closed. This could lead to unexpected results, so this has been changed so that
the data order depends on the order in which the sinks are open.
relaxng.compile-schema.
letters declaration.
field references had been omitted from the
grammar.
string function outputs to its inherited
#current-output.
initial clause of an optional argument for a function contained %c, and the function was invoked in an
element rule without specifying an argument, the compiler rejected the
program on the basis that %c was not being processed in the element rule.
key of shelf query was applied
to a field access whose record was specified as an expression.
elsewhere declaration of a record type that
extended a parent type which was in turn referenced as the type of a field of the original record type.
do select-type statement applied to an instance whose dynamic type is
not explicitly specified as one of the clauses could fail to execute its parent
clause.
||* appeared in a
shelf initializer.
#console was encountered in a program.
#current-input is a markup source, it could
be used in a context expecting a string source. This is contrary to the
specification, and is now disallowed.
import
declaration.
overriding function definition
could lead to an internal error at compile time.
dynamic function.
as opaque qualifier on an exported record
declaration did not have to match that of the corresponding elsewhere.
This could allow record fields to be visible in contexts where
they should not have been; this is contrary to the specification and should not
have been allowed.
& was encountered
where a | was expected, and vice versa.
catch was declared to take a
value string source argument, and subsequently used in an
external-text-entity rule.
number of was being applied to a fixed-sized shelf was being
emitted too aggressively, leading to too many false warnings.
-depend command-line
option could not be opened, an incorrect error message was output, followed by
a segmentation fault.
optional markup source argument in an elsewhere
definition of a function.
optional markup source function
argument specified a constant string as an initial value.
optional markup
sink argument in an elsewhere definition of a function.
#suppress was used as the
initializer for an optional string sink argument, and both
elsewhere and as definitions of the function were present in
the program.
processing-instruction rule failed to match the input, and a subsequent one
succeeded.
string sink function that passes its
#current-input to a string source function, whose output it then
parses, could cause an internal error in OmniMark.
has key test to fail even
though
an item existed with such a key.
markup-error rule could cause a memory leak.
#markup-error-total if a markup-error rule signalled its #current-markup-event to another markup-parse.
%c consumed in a streaming fashion inside a data-content
rule would be interrupted by CDATA and SDATA entities.
do markup-parse consuming #content of an element
that changes the namespace could cause an internal error.
processing-instruction rule or a
translate rule containing the named pattern.
< in
attribute values.
document-element parameter would lead to a
segmentation fault at run-time.
omxmlwrite library could lead to
a character entity in the output appearing in a context where one is not allowed.
string to markup-buffer has been
added to markup utilities.
markup-buffer values can now be compared for equality of their
contents using the = and != operators.
relaxng.compile-schema could return an invalid schema object for
some heavily recursive RELAX NG schemata.
omxmlwrite library are now emitted in
a hexadecimal representation.
named
and valued components. These could never match, and so are now rejected at compile time. This may
cause programs that previously compiled successfully to stop compiling. The solution is to remove the
offending pattern.
%c, suppress, or #content.
do sgml-parse appeared in the wrong order.
optional argument pass-through can now be used in a context
where a conversion-function would otherwise have been invoked. Previously, this had led to a
run-time error.
namecase declaration could affect whether or not a
program compiles. This declaration is deprecated, and has no effect on program compilation or program
execution.
| appeared where a || was expected.
new operator as an argument to a function could
lead to erratic behavior at compile time.
new on a field access in an open action could
lead to erratic results when the type of the shelf item was incorrect.
name of operator in an erroneous context could
lead to erratic results.
dynamic
functions could lead to a segmentation fault at run-time.
match clauses of a do scan block.
function predefined as dynamic and later defined
as not dynamic could trigger an internal error if the latter had no arguments.
name of was
applied to a function.
set was
applied to a function other than a string sink or markup sink function.
#content or #current-markup-event was used in a shelf context (e.g., passed to a function as a read-only
argument).
markup-region-event was being described as user-defined.
conversion-function that was needed in an importing module, an inaccurate error message was emitted.
throw to a
catch target had a comma-delimited argument list and was missing an argument.
optional
argument of type integer had an initial clause with a type other than integer.
instance
keyword is used to invoke the well-formed XML parser.
#content were causing
memory leaks.
string sink function whose
#current-input is being consumed by a string source function could cause a
subsequent signal from the latter coroutine to be misdirected.
signal throw destination
coroutine, the always clauses in the signalling scope would not run.
signal throw actions with no intervening
output could end up being uncaught if the target coroutine delegated its work to another coroutine.
string source coroutine wrapped in a string sink coroutine could cause a segmentation fault.
previous is could fail
inside a do markup-parse.
stream was
attached with referents-allowed to a referent that had previously been attached to a stream with referents-allowed.
%c in a different coroutine than the one
that started the parse could lead to uninitialized memory access.
signal throw on a coroutine that has already
terminated could cause a segmentation fault.
markup sink, markup
source, and markup sink return types, each invoking the next in turn, could cause a
segmentation fault.
copy and save applied to a stream containing
referents could lead to incorrect output or internal errors.
%c directly could behave differently from
passing it as a value markup source function argument and outputting the argument.
copy or save of a stream opened
with referents-allowed and then closed could lead to a later segmentation fault.
%c and #content in a
markup-comment rule did not behave the same.
markup source function in a pipeline by an
equivalent function of markup sink type could cause markup event signals to not be caught.
element rule triggered from a markup
sink function could cause a memory leak.
external string source function in a
markup-processing pipeline could cause an internal error and bad memory access.
#current-markup-event in an element rule from
inside a %c scanning scope yielded the last parsed element instead of the element that triggered the
rule.
do markup-parse of the element events,
could lead to an internal error or wrong behavior.
do
markup-parse and the original parse was killed immediately after that, an internal error would result.
omxerces
library, for valid UTF-8 input.
uri.parse in OMURI
library, when given a relative path, was incorrectly providing both the relative and absolute path in its
uri-components argument.
utf8.code-point and utf8.multi-byte-char in the library omutf8 accepted so-called overlong sequences.
uri.parse function from omuri
now decodes the hex-encoded characters.
uri.parse in OMURI
library failed to parse URIs with registry names containing special characters.
do select construct.
record instance were expanded in the variable view before
stepping over an action that releases the record instance, debugging could not continue.
remainder function arguments did not show in the variable view during debugging.
string sink function was invoked.
Use default working directory checkbox in
OmniMark launch configuration was always reverting to active state.
-reqkeygen command-line option was outputting a wrong error message when used incorrectly.
referent value.
element end tags were duplicated in the right pane of the Parsing Sources view.
constant values has been improved.
number of.
constant shelf item could not be used as an initializer in an elsewhered
function definition.
constant string shelf appeared in a pattern.
markup source called within the body of a do xml-parse or
do sgml-parse scope was unable to signal markup events.
constant shelf declared with an empty initializer is no
longer allowed in a value context: a compile-time error is now emitted. Such a
reference would have triggered a run-time error in previous versions of
OmniMark.
integer
from the command-line using the -c command-line option.
escape declaration in a module could affect the importer, and vice versa.
%g format item on an optional string function argument inside of a
conditional operator could lead to an incorrect run-time error about accessing
an unspecified optional argument.
escape declaration in a program containing a not-reached with no argument or
an asserg with no argument could cause the otherwise valid program to be rejected.
with modifier
specifier were incorrect.
conversion-function did not specify an external library binding.
#base and #full element rule lists were not both
being searched.
stream output.
referents-allowed could exhaust the number
of file handles available.
#dtd external text entity to a
file could lead to a segfault if the #content from the failed parse was fed to
do markup-parse.
#content in a data-content rule led to an internal
error.
#content.
%c could cause an internal error.
cdata or rcdata marked section could lead to a segfault at run-time if no
rule fired in response to the event.
string source literal directly passed as a value string source to a function did not match value-start.
external-text-entity rule was using #library and #libpath shelves from the module where the markup was
first parsed, not from the module with the do markup-parse action that
triggered the rule.
%c was scanned or
submitted in presence of a markup-error rule.
markup-error rule that performs a signal
throw of its #current-markup-event into a markup-processing pipeline
could cause an internal error.
#content was interrupted more than once and then continued from inside a
markup comment region.
creating sgml-dtds or creating
xml-dtds clause was used, the content had to be processed by %c or
suppress, as #content attempted to parse beyond the DTD end.
do markup-parse was directly applied to a %c, external text entity references were being attached to the inner parse
instead of the outer one. This could lead to input corruption and internal errors.
signal throw sent to a coroutine that was
delegating their handling to another coroutine could not always get through.
external-text-entity rules triggered by a do markup-parse were inheriting domain-bound global variables from the
domain of the original parse, not the parse that triggered them.
saved.
%v on a CDATA attribute could cause an
internal error if a translate rule suspended to a different coroutine.
&#nnn; could be corrupted when
captured by #content and then recaptured.
markup-parse before being handled, an internal error was reported.
do markup-parse action was applied to a
malformed stream where a markup-comment region contained markup events,
an internal error was reported instead of a program error.
last content is #data would return an incorrect
result if the only data were character entity references.
string source function
feeding a markup parse could trigger a segmentation fault at run-time.
markup-comment rule was processed by
another coroutine.
LF) characters inside the #content of a markup-comment, invalid-data, or markup-region ignore would be expanded into the CR LF character
sequence.
signal thrown to a chain of alternating markup sink and markup source functions could end up uncaught.
processing-instruction rules continue to be
triggered as before, to maintain backwards compatibility.
marked-section ignore)
still fire, as before. This limits any backwards compatibility issues.
#doctype was not being attached for a well-formed XML parse, even though the
input contained a DTD.
dtd-start and dtd-end rules were not being fired when a well-formed XML parse
was launched and a DTD was present in the input. This could make it difficult to
write generic markup handling code. The behavior is now consistent across all
parse types.
ns attribute was not being inherited for include elements.
x or g format item.
name of notation named "a".
throw or a run-time error from the body of an external-data-entity rule would lead to unpredictable run-time behavior.
string sink could not be used as a cast.
%c was not streaming properly when it appeared embedded in a
larger string.
with utf-8 argument to do sgml-parse was
erroneously being evaluated after the input to the parse had begun executing. This contrary to earlier
versions of OmniMark, where it was evaluated before the input. The proper order of evaluation has been
restored (i.e., with
utf-8 is evaluated before the input).
with utf-8 modifier was being ignored when using the
subdocument option of sgml-parse.
binary operator or the complement
operator were used in a shelf reference context, an internal error would be triggered.
new applied to a stream shelf was passed as a shelf-class argument to a function.
with id-checking parameterization was being allowed when
launching the well-formed XML parser. This is contrary to the specification.
dynamic and/or overriding functions could lead to misleading error messages.
do markup-parse could trigger a
segmentation fault at compile-time.
void action was applied
to an invalid type was misleading.
save or save-clear to a string source or string sink was confusing.
catch could not be declared following the declaration of a
record type exported as opaque.
#xmlns-names is now declared as a string shelf, rather than as a stream shelf. This change can be reflected in certain error
messages.
repeat over with an alias, no warning was emitted about it being otherwise unused.
else clause
appeared in a do select-type block containing an invalid type name as one of its cases.
else clause of a do ... done block, the line number reported in the error message would
point to the last
action of the previous block.
string sink identity cast (i.e., casting a string
sink expression in a context requiring an expression of type string sink) would lead to an
internal error at
compile-time.
match clause of a do
scan ... done block, the line number reported in the error message would point to the last action of the
previous block.
repeat over two shelves of differing
sizes, if the larger shelf was declared variable. This is contrary to the specification and contrary
to statements made in the documentation.
repeat
over where a pseudo-shelf or a variable-size shelf was also present (e.g., attributes), an invalid
error message was triggered, claiming that the shelves have different sizes, even when the pseudo-shelf was
also empty.
and infix operator by a user
declaration, and then used it between two string sinks, would no longer compile. Such a program is
valid and should be accepted.
optional value string sink function argument could not
have an initial clause containing a conditional operator.
overriding
of a dynamic function was dispatching on an exported type, but not itself exported.
-depend command-line option now includes
external function library information in its dependency graph.
overloaded function was not being correctly parsed by the OmniMark compiler. This would lead to a syntax
error. A workaround was to insert additional parentheses around the argument.
void on a string source expression could lead to
inefficient execution.
read-only stream in a string
sink context could lead to segmentation fault.
string value in a string
sink context could lead to segmentation fault.
variable and/or size with a
shelf declaration could lead to a confusing error message.
initial as a function
argument herald was not being handled properly in various contexts. This would lead to the rejection of correct
programs.
optional string
sink argument initialized to a stream would lead to a segmentation fault at run-time.
xmlns-change rule in a multi-module program, where the main
module ends with a function, could cause all rules in other modules not to fire.
external-text-entity rule would lead to a segmentation fault.
external-text-entity rules and
external-data-entity rules could lead to unpredictable behavior in later parts of the program.
throw or a run-time error from the body of an external-data-entity rule would lead to unpredictable run-time behavior.
catch
clause arguments was confusing.
read-only stream to a function expecting a value string sink argument would lead to a confusing error message.
value switch argument
was aliased in a repeat over loop. A workaround was to drop the alias and use the argument name
directly.
read-only stream was
used in the header of a using output as did not make sense.
counter was used as a type herald, the error message
thereby triggered referred to integer as the type.
int32 was used as a type herald, the error message
thereby triggered referred to integer as the type.
take on a string source on the right-hand side
of a matches could lead to the string source being entirely consumed.
#current-input or #current-output in a
using shelf item association would trigger an internal error at compile-time.
#current-output was accessible in the body of a markup sink function. This is contrary to the specification.
markup sink function was being rejected on the left-hand
side of set.
record types were being
assigned.
join in a find rule could trigger an incorrect
compile-time warning, and could also negatively impact performance.
repeated (||*) in a pattern was not being compiled
properly; this would lead to inefficient execution at run-time.
g format item is
encountered alone in a string; the use of the g format item in this way is redundant, and should be
eliminated.
string in a
g format item referenced the wrong line in the program.
require
qualifier was encountered in a shared module.
set new action on a record shelf was not constructing intermediate values.
external-text-entity rule in OmniMark 8 was run in a
coroutine whose parent was the current element rule, in contrast to the correct input domain parent
coroutine in earlier versions of OmniMark. The behavior has been corrected.
sgml-in and sgml-out were being
incorrectly propagated to XML parses launched as children of a parent SGML parse.
output action
before trying to consume its input, it could be left suspended in that position. This caused problems if the
suspension preceded a catch clause that was supposed to handle signals coming through its
input.
string was returned
from a function, and the string was a run-time constant (e.g., the name of an external string
sink attachment).
#markup-error-count and #markup-warning-count were not local to the current parse in case of multiple co-routining parses.
throw from a string source function used by a do xml-parse could cause a memory leak.
stream attached to a referent unclosed by
the end of the referent scope could lead to a segmentation fault.
markup-error rule could cause the
subsequent markup error reports to leave out the exact error locations.
status of last subelement is
inclusion test could return an incorrect result.
log directive in a markup-error rule launched from
one parse could affect the logging of a different markup-error rule.
referents could not be written to a
stream attached to a referent, even though referents had been enabled.
stream attached to a referent
that had previously been assigned a value with referents-allowed, was being appended to the
previously-assigned value rather than replacing it.
name of #suppress would lead to an internal error at
run-time.
#suppress has name would lead to an internal error at
run-time.
#current-input in a
string sink function was interrupted by a signal, it could not be resumed if the take operator was being used.
element rule was fired, OmniMark would report an error
message with no file name and line number.
new could lead to a run-time
error about accessing a non-existent shelf item.
%13#) to propagate to the output: this is contrary to the XML specification.
signal sent to multiple coroutine sinks (combined into a
single sink by the & operator) at the same time stopped its propagation as soon as one of the target
coroutines suspended to any coroutine other than the signalling one.
output-to at the top-level of a string
source function called as the argument to file would lead to a segmentation fault at run-time.
%c was run in a separate coroutine, the modifiers were ignored.
notation in a DTD scanned by the
well-formed XML parser would trigger an internal error.
translate patterns erroneously matched a content-end when content was interrupted by a processing instruction, comment, or marked section.
signal thrown from a markup rule could cause an internal
error.
string sink function
with referents-allowed was passed to a second function as a value string sink argument, and
the latter function terminated without yielding to its argument. Typically, this meant the argument was not
accessed in the body of the second function.
joins would lead to a segmentation fault at
run-time.
string sink function that parses its #current-input.
throw occurred in a
markup-error rule and a processing instruction was being parsed by the well-formed XML parser.
markup-comment rules were present in a program, the
text of every markup comment that did not trigger any of the rules would be submitted to translate
rules, when it should have been suppressed instead.
notation declaration was encountered.
-- in comments; this is contrary to the specification.
notation was triggering a markup
error in a well-formed XML parse; this is contrary to the specification.
notation in a DTD
scanned by the well-formed XML parser would trigger an internal error.
doctype keyword.
cgiGetQuery
could fail with a program error for certain inputs.
HttpRequestSetFromUrl in the OMHTTP library did not correctly parse a URL if the query string component contained an @
sign.
signal throw and put actions.
step over command on an action that
applies new to a record-type shelf would execute the rest of the program to the end.
matches, take, or drop expression would outlive the scope
of the expression.
string sink literal erroneously referred to the production for [void function call], where the
production for [value function call] was meant.
null
character would be truncated, thereby making it inaccessible.
conversion-function from numeric-literal to string.
conversion-function was being silently accepted. A
compile-time warning is now generated where a conversion-function may recurse.
require a record
type was misleading, implying that record types cannot be exported.
constant shelf of
size 0; this is no longer needed.
element names were referred to as GIs in certain error messages.
#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).
-ftrace command-line option was used.
string source to a function accepting an
argument of class read-only would trigger an internal error.
-ftrace option could lead to an internal error in programs
using catch/throw.
string shelf item
appeared in a position where a character class was expected.
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.
overriding of a dynamic function for a type that is not visible.
referents, indexed by item number, i.e.,
output "d" % item of referents[1] || "%n"
catch was being referred to as a function.
new on a switch in an expression context.
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.
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.
append modifier could not be used in conjuction with the new
operator on the left-hand side of the open action.
set.
declare data-letters declaration
referred to it as the (deprecated) letters declaration.
declare name-letters declaration.
shared as name in an interface module would lead to a segmentation fault when the corresponding implementation module was imported.
overloaded function was declared as either value source or value output.
current elements pseudo-shelf is accessed in a context where it is guaranteed to be empty.
overloaded switch function could not be used in a find rule.
value string source argument to a function taking a read-only string argument would trigger an internal error.
returns in function bodies were not being emitted.
record type that extended another pre-declared record type.
overloaded when it was previously-defined as overloaded would lead to an incorrect error message.
next group is in a find rule did not affect the find-end rules' active group.
null character would be truncated, thereby making it inaccessible.
conversion-function from string source to switch could not be invoked: an error was emitted claiming that a type cycle had been created.
string source cast on #current-input was causing the input to be buffered. This was both unnecessary and incorrect.
new operator applied to strings and streams would lead to an internal error in the OmniMark compiler.
doctype is test inside a repeat over loop could lead to a segmentation fault.
value argument as a shelf-class argument (i.e., read-only, modifiable, or write-only) to a
catch would trigger an internal error.
elsewhered, never defined, and called in a using input as qualifier, would lead to an internal error at run-time.
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.
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.
value string sink argument would lead to a segmentation fault in the compiler.
stream indexed numerically to a function as optional string sink argument could corrupt the optionality of other arguments.
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.
#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.
dynamic function on an undeclared shelf could lead to an internal error.
string could not be copyed to a shelf of type
stream. This operation is well-defined and should be allowed.
else clause of a do...done block
pointed to an incorrect line number.
-load command-line option now indicates so.
name of on supplied external string sink functions did not always return the correct name.
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.
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.
external-text-entity rules in one module was turning off default entity resolution in other modules.
repeated (||*) operator on a string longer than 4096 characters.
string source being matched could erroneously fail.
content-start pattern was sometimes erroneously succeeding at a point following an entity.
repeat over #libpath, inside an external-text-entity rule.
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.
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.
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.
external string sink function could crash at run time.
value-start pattern didn't match on the beginning of a source created using drop operator.
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.
null characters were truncated when emitted by assert or not-reached.
translate rule header could cause a segmentation fault.
halt-everything in markup-error rule would cause a segmentation fault at run time.
string source function could raise an internal error.
find-start rule could affect the element rules' active group.
optional argument to an external function was treated as specified.
write-only.
string sink function passed as an argument to an external function did not receive any input until the external function closed it.
value string sink arguments could not be passed a multi-component sink, constructed using operator '&'.
#current-output in an always clause could lead to a segmentation fault if the current output was a coroutine that executed halt.
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.
string source that was consumed as a part of a join could sometimes be scanned again outside of the join.
join of multiple string sources was scanned and then restored to its starting position, the join's components' positions were not restored.
-warning specified, but no total warning count.
#main-input and #process-input string sources to be used together even when there were no input files specified.
log-message could unnecessarily consume large
amounts of memory.
modifiable stream argument have been generalized to take a write-only string argument.
vfs.connect-directory was expecting a "file:" protocol specification. It now works on plain file system paths.
vfs.copy was failing to copy symbolically linked directories on Unix platforms.
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.
OM_PersistentSource_t::AtEnd () that provides access to the low-level
C API call OMXF_SourceAtEnd ().
string or stream, and of
shelf class (i.e., read-only, write-only, or modifiable).
opaque, and of shelf
class (i.e., read-only, write-only, or modifiable).
external string sink would refer to it as a persistent source, rather than persistent sink.
db.insert, db.update, and db.delete that operate on tables now can handle table and field names with non-alphanumeric characters.
global referents entry in the variable table now appears only if the program uses referents.
cross-translate, could be run but not debugged in Studio for Eclipse.
throw from within a using nested-referents scope would terminate the current debugging session in OmniMark Studio.
-ftrace option was missing from the OmniMark Studio debugger.
#external-text-entity #document rule was not working in the OmniMark Studio debugger.
#external-test-entity rule could terminate the current OmniMark Studio debugging session.
global or constant shelf could stop the Studio debugger.
invalid-data rule could cause the OmniMark Studio debugger to prematurely quit execution.
-help command-line option text did not specify the arguments for
the -gc-threshold and -gc-increment options.
#appinfo information was accessible from an XML parse
nested in an SGML parse.
#current-output from a function called within a fork
(i.e., the & operator) could go to another stream specified by the
fork.
using output as (and similar constructs) with
multiple destinations could be confused by extra parentheses around
the first stream.
using attribute scope containing "%c" could cause an internal
error in some cases.
string source function used on the right-hand side
of a scanned join operator (i.e., ||) was sometimes discarded.
always clause could stop exception propagation.
submit action in a pattern matching context (e.g., do scan), prefixed by a using output as would lead to an internal error.
submit of a string source derived from the output of a parse could
cause a segmentation fault.
string source as a string sink would lead to an
internal error in certain circumstances.
binary operator could not be overloaded.
difference, format, mask, modulo, shift, and
union could not be stropped (i.e., escaped using the backtick)
process-end rule in an implementation module would cause an
internal error.
document-start, docuement-end,
find-start, or find-end rule is encountered in a module; these rules
cannot be triggered within a module.
is keyed shelf query is applied to
a keyless shelf; this test is invariant and should be removed.
-ftrace command-line option, the compiler could
report that a valid function definition was invalid.
#markup-parser sink from an element rule would
cause an internal error instead of throwing to #program-error.
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.
open or reopen did
not have any effect.
buffer attachment type did not allow modifiers to be specified.
value string sink arguments was not
reported at compile-time, and could lead to a segmentation fault at
run-time.
open-only modifiers,
like text-mode, in other contexts like using output as.
reopen...as was applied to a stream that cannot be reopened,
an invalid error was reported.
string sink or string source
would lead to an internal error.
new operator appearing where a string sink was expected could
cause a segmentation fault. This is now a compile-time error.
++ operator sometimes did not restore the input consumed.
string sink functions from external filter libraries (e.g.,
omffbase64) would close persistent string sinks (such as #main-output) that were
passed to them.
string sink function passed as an argument to an
external function would not see the data written into it by the
external function.
#current-output has name caused an internal error instead
of a proper compile-time error.
#current-output as a write-only argument could cause an
internal error instead of a proper compile-time error.
string coercion could cause an internal error in certain contexts.
item of applied to a shelf
indexed by item).
lookahead not not would lead to an internal
error, rather than a syntax error in certain circumstances.
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.
return (from an always clause) from a string source or
string sink function caused an error.
catch declaration would lead to an
internal error in a catch clause.
string source
function was lazily consumed.
constant shelves
declared with the same name, but with different types.
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.
save a constant
specified the wrong type.
using nested-referents
scopes.
catch invocation could be left out. This is
contrary to the specification: the herald is now required.
string sink function in a using shelf item
association would trigger a misleading error message.
value string source
argument appeared in a using shelf item association.
value string sink argument in a
using shelf item association.
save groups was
encountered was incorrect.
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.
convert tabs to spaces preference did not have the desired effect.
Step Over action at the end of a coroutine would run until the end of the program.
-f command-line option on Unix did not accept OmniMark project
files (.xop) produced on Windows.
switch cast would cause an internal error.
#current-input is attached test returned a wrong value in some
circumstances.
is specified test on optional arguments to a
function was incorrect under certain circumstances.
string source coroutine was output through an intermediary,
context switches did not occur until the coroutine was finished.
initial clause was specified on an
optional argument of class other than value.
newon a shelf literal heralded by an undeclared type
would trigger an internal error or a segfault in the compiler.
using output as to be applied to the result of
operator new.
catch arguments.
#current-input in
several contexts where #current-input would be unattached at
run-time. This moves an error from run-time to compile-time.
#current-input in a string source function. This error used to be caught at run-time; it is now
caught at compile-time.
sink would cause an internal
error.
export as opaque catch.
capture-environment in the library OMUTIL was not
displaying error messages in failure cases.
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.
markup-error or sgml-error rule: this
style is deprecated, and its support will be removed in a future
version of OmniMark.
#console is encountered; #console is
deprecated.
drop, matches and take did not try to invoke conversion
functions on their first argument.
item of was applied
to a shelf indexed by item.
any{"%d(i)"}, where i is an integer, was being
rejected.
return action in a function body.
#current-input from a string sink function
cannot be used as a value string source function argument has been
removed.
streams if one item on the
shelf was unattached.
any* would consume only up to 2 GB of data. This
limitation has been removed.
repeat over loop inside of a catch clause would scramble the
information required to rethrow the exception.
with append modifier had no effect when assigning to a
referent.
modifiable record types would
collide. This restriction has been removed.
is default-entity test caused it to always
evaluate to false.
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.
switch shelf item using an item indexer was
not being handled properly, which could lead to erroneous behavior at
run-time.
any* when true.
find-start rule
for a cross-translate program.
lastmost indexer on a shelf-class function
argument could lead to a segmentation fault in the OmniMark
interpreter.
% (format) operator was not being handled properly in a pattern
context.
referents shelf now supports the new indexer syntax.
any** were not being evaluated correctly.
->) did not handle user-defined types
properly.
any** (or any++).
number of sgml-dtds.
scan input #main-input in an XML parse.
-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.
throw occurred inside a
repeat over current elements.
elsewhered) definition, which was satisfied in
the importer. This has been disabled.
repeat over current elements loop to change
the name of the current element obtained via the name of element
expression.
last content is appearing outside of a parse would cause the
OmniMark run-time to segfault.
new as the read-only argument to a
function would cause an internal error.
clear sgml-dtds{""}.
is specified
applied to a shelf with a key-based indexer.
name of operator has been improved.
name of operator is applied to
a value stream argument has been improved.
remainder source.
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.
find any ++ => p lookahead ("Hello, World!" | =|)
record type that the other extended.
dynamic function had to be declared as overloaded as well, if an
overriding was declared in a different module.
referent
"..." to be used wherever a stream shelf reference was required.
#current-input was not inherited from the invoking domain to the
input domain when invoking a markup-parser.
dynamicfunction declaration could cause an
internal error in the OmniMark parser.
new has led to a number of
issues being fixed in its implementation.
down-translate was begun
on a truncated input.
repeat over on an empty constant or global shelf would cause an
internal error.
** pattern operator has been improved.
process local stream s initial { "Hello, World!" with key "Salut, Monde!" } set key of s{"Salut, Monde!"} to "Salut, Monde!"
value was not being handled correctly when used as a
function argument herald.
stream-returning function to a stream shelf has
been optimized.
referents and records would cause a crash at
execution time.
activate or deactivate on an
expression involving cast.
dynamic
function involved the cast operator.
is specified test was not being evaluated correctly in a
well-formed parse.
using a field of a result of a record-returning function has been fixed.
and, couldn't be exported from modules.
item of a built-in stream shelf like #current-output caused an internal error.
elsewhere function definition.
with append modifier in some situations didn't work properly on buffers.
repeat over action didn't check if the shelf was an unspecified optional function argument.
copy action didn't check if either of the shelves was an unspecified optional function argument.
catch and always.
#current-input appearing after an action containing the drop operator referenced the result of the drop instead of the contextual current input.
#main-input in memory.
new applied to a stream shelf literal would cause an
internal error in the compiler.
format function using a different signature.
source function call.
repeat over or using of a value string argument, using a shelf reference
alias, was not being handled properly by the OmniMark compiler.
OCI backend
db.discard function on a compiled statement used for a
streaming insert no longer causes a crash
ODBC backend
markup-parse is being performed using the omxerces library and XML schema validation is active.
and has been fixed; these are now handled correctly.
insertion-break or replacement-break were erroneously being rejected; this has been fixed.
insertion-break or replacement-break; this has been fixed.
#current-output following a drop expression on something other than #current-output; this has been corrected.
#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.
as definition and an elsewhere definition. This has been fixed.
elsewhere definition for a function without also exporting an as definition for the same function.
#args, rather than the deprecated #command-line-names.
elsewhere declaration.
using prefix.
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.
content is declared-empty is only true when an element is
declared empty.
content is empty-tag is only true when an element has an empty
tag.
TCPConnectionGetOutput and TCPConnectionGetSource now set return values properly when applied to a TCPConnection that is in error or not connected.
tcp-accept-connection in the omtcp library to crash or enter an infinite loop when receiving many requests quickly.
bcd values. This has been fixed.
describe now works on read-only devices, such as CD-Roms.
make-directory now gives new directories the correct access permissions.
describe now takes Daylight Savings Time into account when reporting file access times.
ldapOpen will now allow port numbers up to 65535.
ldapCreateAttribute, ldapAttributeGetValue, ldapAttributeGetValues and ldapModifyEntry now check the datatype parameter.
MailInBoxGetMessage caused extra null bytes in lines that were longer than 512 characters.
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.
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.
NaN is now platform-independent
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.
Desktop Engine and Server Engine on the Windows platforms now correctly handle reading from standard input, when running as a CGI under IIS5.
file...is writable test works correctly for non-existant files in a writable directory.
always blocks now execute after uncaught external exceptions.
The following problems have been fixed in version 6.1.2
new my-shelf {"d" % i}or by issuing
set new my-shelf {"d" %i} to "fred"
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.
The following problems have been fixed in version 6.1
Problems have been fixed so that OmniMark Studio for Eclipse
For further information, see the OmniMark Studio for Eclipse Windows help file.
The following problems have been fixed in version 6.0.2
integer and counter are useable interchangeably as casting operators for user-defined conversions function casts.
using #group will now save the group set for restoration.
#current-input matches... certain patterns will not cause characters to be consumed from #current-input even when the matches failed.
The following problems have been fixed in version 6.0.1
The following problems have been fixed in version 6.0. This list includes fixes to problems discovered in public betas of OmniMark 6:
copy-clear produced a run-time error when used on a modifiable shelf function argument.
null pattern modifier did not work correctly with repeat scan.
++ 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.
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.
name of #main-output was causing a syntax error.
#external-exception did not result in a throw to #program-error.
ul pattern operator scope was incorrectly extended to the end of the pattern.
word-end was being handled incorrectly. This was introduced with OmniMark 5.3.
do when <string-expression> matches ...was not supported. This error was introduced with 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.
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.
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.
The following corrections have been made in OmniMark 5.1:
or bar character ("|") in source code.
join or repeated. This might break existing OmniMark 5 programs
that took advantage of this.
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.
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:
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 [^'"']* '"') => linkcaused 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.
The following errors have been corrected in OmniMark CI 4.0.2:
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.
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.
attributes lastmost is used, an incorrect error message is reported.
The following errors have been corrected in the OmniMark Kernel:
The following errors have been corrected in OmniMark CI 4.0.1:
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.
sgml-out <dynamic string value> causes a memory leak.
set new statement, as in set new s to s || ".txt".
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.
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 1The 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.