 |
|
|
|
||||
|
|||||
|
|
|||||
| Related Topics | |||||
What's fixed |
|||||
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.
|
Related Topics
|
Copyright © Stilo International plc, 1988-2010.
