RE: some basic questions

["Reynolds, Gregg" <greynolds@xxxxxxxxxxxxxx>]

I see your point but I would add a couple points in hopes of preventing
confusion among newbies.  At the bottom of this message is a question
you may be able to answer for me.

First off would be to distinguish between languages and features.  DSSSL
specifies four languages: expression, SDQL, transformation, and style.
Furthermore, it specifies core and full sets for the expression and SDQL
languages; for the transformation and style languages it enumerates
optional features.  Both the transformation language and the style
language "use" (some subset of) the expression language and SDQL; we can
therefore consider the latter as "foundation" languages, and the former
as "output" languages.  The optional features of the output languages
provide a way for implementors to indicate which subsets of the four
languages they support.  Features may refer to parts of the foundation
languages or of the output languages, or both.  Notice the symmetries.

Jade supports (some subset of) the expression, SDQL, and style
languages.  It does not support the "query" feature of the style
language, which "allows use of the full query language described in
chapter 10 *and related facilities described in this [the style]
clause*.  Without this feature only the core query language shall be
used."  In other words, there are certain features of the style language
that require more than just the core subset of SDQL;
"query-construction-rules" is one of them.

It's worth emphasizing that the style language is concerned solely with
producing output.  It "constructs" output using "construction rules", or
which there are 6 types, 5 explicit (query, id, element,
default-element, root) and 1 implicit (default).  (The implicit default
rule is defined by DSSSL (p 175), always in operation, and may not be
changed; the "default-element-construction-rule" is explicit, optional,
and user-defined.  This has been a point of confusion here before.)
There is no "normal" construction rule.  

The expression and SDQL languages, on the other hand, have nothing to do
with output; SDQL, in particular, is only concerned with manipulating
the document grove.  One _may_ use SDQL to obtain information from the
document, and apply the style language to the information to produce
output.  Or, one may rely on construction-rules alone, which may be
thought of as a kind of implicit query.  In fact, a construction-rule
may be considered as a query statement intended specifically to select a
set of nodes for association with a style specification.

I hadn't really looked into the query-construction-rule before your note
sent me scurrying to my copy of the standard.  Now I can categorically
state:  hmmmm.  Very interesting.  One could for example emulate
element-construction-rules using query-construction-rules, no?  I have
always thought of DSSSL as providing two distinct models of producing
output, one based on queries (just like RDBMS processing) and the other
input-driven ("events" in the input text stream "triggering" the
"handlers" registered via construction-rules).  But the
query-construction-rule really kinda sorta unifies these two models.
Again I say: hmmmm.  What remains murky to me is how the
query-construction-rule is triggered.  I'll quote here from Chris
Maden's response to your note:

"The times I've wished for the query feature, it's been to match non-
element nodes, like processing instructions and sdata entities."

Though I understand how the query-expression of a
query-construction-rule might select such non-element nodes, I don't see
how the rule gets triggered in the first place.  I think I've made the
assumption that element nodes (ie the tree? or is it the grove?) drive
the selection, but now looking in the standard I don't see any language
that necessarily implies that model.  I'm looking in 12.4.1, p 174.  Can
anybody shed some light on this?



	-----Original Message-----
	From:	W. Eliot Kimber [SMTP:eliot@xxxxxxxxxx]
	Sent:	Friday, April 10, 1998 1:54 PM
	To:	dssslist@xxxxxxxxxxxxxxxx
	Subject:	RE: some basic questions


	What Jade doesn't support is the query *feature* of the style
language,
	which means that you can't use query construction rules.
However, you can
	get around this by replacing the normal construction rules with
a single
	default rule that uses a COND expression to apply queries to the
current
	node, e.g.: 
	<snip>



Gregg Reynolds



 DSSSList info and archive:  http://www.mulberrytech.com/dsssl/dssslist