Index of /pxsl/sources/pxsl-0.9.1

 Name                         Last modified      Size  Description
 Parent Directory                                  -   
 GetInput.hs                  28-May-2003 16:41  2.7K  
 LICENSE                      21-May-2003 14:52   15K  
 MANIFEST                     17-Jun-2003 12:20  264   
 Makefile                     17-Jun-2003 12:10  4.8K  
 PxsltElementDefaults.hs      28-May-2003 23:43  5.0K  
 PxsltFormat.hs               05-Jun-2003 15:37  4.3K  
 PxsltMacros.hs               17-Jun-2003 12:13  3.6K  
 PxsltParser.hs               17-Jun-2003 12:15  6.9K  
 PxsltParserTerms.hs          03-Jun-2003 12:23  5.4K  
 PxsltParserTreeTransforms.hs 28-May-2003 23:47  2.7K  
 TODO                         12-Jun-2003 03:33  2.5K  
 XmlString.hs                 01-Jun-2003 17:04  2.6K  
 examples/                    12-Jun-2003 03:25    -   
 gmap-5.0.tar.gz              01-Jun-2003 14:15   76K  
 pxsl-tools.spec              17-Jun-2003 12:20  1.1K  
 pxslcc.hs                    05-Jun-2003 12:00  3.7K  
 text-to-html.pl              05-Jun-2003 16:54  1.7K  
 xsl2pxsl.xsl                 01-Jun-2003 13:40  1.9K

PXSL README

PARSIMONIOUS XML SHORTHAND LANGUAGE

$Id: README,v 1.12 2003/06/12 04:52:18 thor Exp $

PXSL ("pixel") is a convenient shorthand for writing markup-heavy XML documents. The following document explains why PXSL is needed and shows you how to use it. For additional information, visit the community site:

http://community.moertel.com/ss/space/pxsl

You'll get more out of this document if you read it from start to finish, but you can stop anywhere after the "Gentle Introduction to PXSL" and be able to take advantage of PXSL in your documents. The later sections explain PXSL's advanced features. If you're willing to invest some time in learning them, you will have at your disposal new and powerful ways to create and refactor XML documents. The advanced features are more complicated to master, but they can greatly reduce the complexity of your documents.

* Getting PXSL * Getting help * License * Getting or building the PXSL tools * Gentle Introduction to PXSL - Why PXSL ? - A closer look at PXSL - Using PXSL documents * Advanced topics - Element defaults provide convenient, customizable shortcuts Using element defaults to create attribute shortcuts Using element defaults to create virtual elements Making and using your own element defaults Built-in element defaults for XSLT stylesheets - Advanced quoting with << >> and <{ }> - Macro facility - Advanced macros and passing parameters with the <( )> delimiters - Insanely advanced macros and functional programming - Automatic PXSL-to-XML conversion via Make * Reference: pxlscc * Reference: PXSL syntax * Authors

Getting PXSL

The most-recent official version of PXSL can always be found here:

http://community.moertel.com/pxsl/

By the way, you pronounce PXSL like "pixel".

Getting help

If you need help with PXSL, there is a discussion site for PXSL users and developers. Feel free to ask questions and leave your comments:

PXSL Community Forum http://community.moertel.com/ss/space/pxsl

PXSL FAQs http://community.moertel.com/ss/space/PXSL+FAQs

LICENSE

The PXSL toolkit is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

The text of the GNU GPL may be found in the LICENSE file, included with this software.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

Except as provided for under the terms of the GNU GPL, all rights are reserved worldwide.

Getting or building the PXSL tools

If you don't want to build the PXSL tools from source code, you can download one of the pre-built binary packages on the PXSL web site. If a binary package isn't available for your computing platform of choice, you can use the following procedure to build the PXSL tools for your platform.

In order to build the tools you will need the following:

- A PXSL source tarball (typically named "pxsl-{version}.tar.gz") http://community.moertel.com/pxsl/

- GHC Haskell compiler, version 5.04.3 or greater http://www.haskell.org/ghc/

- Make (GNU's flavor preferred) Windows users: install Cygwin, which includes GNU make: http://www.cygwin.com/

Once GHC and Make are installed on your computer, uncompress the tarball and build the project via the "make" command:

$ tar zxvf pxsl-{version}.tar.gz $ cd pxsl-{version} $ make

(Replace {version} with the version of PXSL that you downloaded.)

That's it. You should now have a fully functional version of pxslcc.

Gentle Introduction to PXSL

PXSL ("pixel") is a convenient shorthand for writing markup-heavy XML documents. This introduction assumes that you are familiar with XML. If you want a refresher, see the introductions on XML available here:

http://xml.coverpages.org/xmlIntro.html

Why PXSL ?

XML is a descendant of the markup language SGML and inherits its ancestor's historical bias toward marking up textual documents. However, XML is becoming an increasingly popular medium for the representation of non-textual information such as metadata (RSS, XSD, RELAX-NG), remote procedure calls (SOAP), and even information that looks much like programming languages (XSLT, SVG, MathML). For these uses, XML's text-centric syntax gets in the way.

Consider, for example, this snippet of MathML:

MathML in XML

<declare type="fn"> <ci> f </ci> <lambda> <bvar><ci> x </ci></bvar> <apply> <plus/> <apply> <power/> <ci> x </ci> <cn> 2 </cn> </apply> <ci> x </ci> <cn> 3 </cn> </apply> </lambda> </declare>

Notice something about MathML's structure: There is more markup than text. In fact, the only text in the snippet is "f x x2 x3"; the rest is markup. As you can see above, XML's document-centric style of markup, in which the markup is delimited from the flow of surrounding text, becomes a hindrance when markup is in the majority.

PXSL, by contrast, was designed specifically to handle this case well. It makes dense markup easy because it assumes that everything is markup to begin with. You need only delimit the few portions of text that are mixed into the flow of surrounding markup.

In other words, PXSL is what you get when you turn XML inside out:

XML PXSL

<markup>text</markup> markup <<text>>

Let's see how this inside-out transformation simplifies our MathML example from above:

MathML in XML MathML in PXSL

<declare type="fn"> declare -type=fn <ci> f </ci> ci << f >> <lambda> lambda <bvar><ci> x </ci></bvar> bvar <apply> ci << x >> <plus/> apply <apply> plus <power/> apply <ci> x </ci> power <cn> 2 </cn> ci << x >> </apply> cn << 2 >> <ci> x </ci> ci << x >> <cn> 3 </cn> cn << 3 >> </apply> </lambda> </declare>

There are two things to notice about the PXSL version in comparison to the XML version. First, the PXSL version is shorter. Second, and most important, PXSL is comparatively free of noisy characters like < > / and ". In PXSL, noise is the exception rather than the rule.

A closer look at PXSL

Writing PXSL is simple. If you know how to write XML, you can write PXSL. In fact, PXSL is XML, just written in a different, inside-out syntax. Let's see how it works by way of comparison.

First, every XML document and hence every PXSL document has a root element. Here is a tiny document that has a root element and nothing else:

XML PXSL

<doc/> doc

If the document contains other elements, they are simply placed underneath the root element, but indented to indicate that the root element contains them. In XML this indenting is optional, but most people do it anyway because it is an established practice that makes documents easier to understand. In PXSL however, the indenting is mandatory because indentation determines which elements contain others. (This requirement is what enables PXSL to do away with the closing tags that XML uses to determine containment.)

<doc> doc <title/> title <body/> body </doc>

If an element has attributes, they are written in the form of -name=value in PXSL.

<doc> doc <title/> title <body id="db13"/> body -id=db13 </doc>

If an attribute value contains whitespace, it must be quoted within the literal delimiters << and >>.

<doc keywords="x y z"> doc -keywords=<<x y z>> <title/> title <body id="db13"/> body -id=db13 </doc>

Now let's consider text. If an element contains text, the text is quoted in << and >> delimiters and indented underneath the element that owns the text.

<doc keywords="x y z"> doc -keywords=<<x y z>> <title/> title <body id="db13"> body -id=db13 This is text. <<This is text.>> </body> </doc>

The << and >> delimiters are powerful. The text within them, including all whitespace, is quoted verbatim. The text can span multiple lines and even stray outside of the outline-like indentation hierarchy. If you place sections of quoted text next to one another <<like>> <<so>> they effectively become one section <<likeso>>.

<doc keywords="x y z"> doc -keywords=<<x y z>> <title> title My title <<My title>> </title> body -id=db13 <body id="db13"> <<This is multi- This is multi- line text.>> line text. </body> </doc>

If you want to add an XML comment, introduce it with the -- delimiter. The comment extends to the end of the line.

 -- my document <doc keywords="x y z"> doc -keywords=<<x y z>> <title> title My title <<My title>> </title> body -id=db13 <body id="db13"> <<This is multi- This is multi- line text.>> line text. </body> </doc>

You can also use the # delimiter, which creates a PXSL comment that is invisible in XML:

That's it. You now know everything necessary to create PXSL documents.

PXSL lets you do more, however, and if you want to take full advantage of it, read the Advanced Topics section. For now, though, let's consider how to use PXSL documents with your existing XML-based software.

Using PXSL documents

Using PXSL documents is easy because they are really XML documents in disguise. (In fact, you may wish to consider PXSL as a convenient shorthand for writing XML.) Any program that can read XML can handle PXSL. All you need to do is remove the disguise first so that the programs will recognize your documents for what they are.

The included tool pxlscc (short for PXSL conversion compiler) performs this task. Just feed it a PXSL document, and it returns the equivalent plain-old XML document:

$ pxlscc document.pxsl > document.xml

You can then use the returned document in your XML-aware programs.

If you know how to use Make or Ant or similar tools, you can easily automate this process so that your PXSL files are automagically converted into XML when needed.

Advanced topics

The following sections describe the more advanced capabilities of PXSL that can make your life easier. The element defaults, in particular, can significantly reduce markup burdens.

Element defaults provide convenient, customizable shortcuts

Most XML documents conform to established vocabularies. Once you become familiar with your documents' vocabularies, you'll probably find that certain elements and attributes always or often occur together -- to the point where typing them becomes repetitive. For example, in XHTML, almost all img elements take the following form:

<img src="..." alt="..." [ additional attributes here ] />

Or, in PXSL:

img -src=... -alt=... [ additional attributes here ]

So, why should you have to type in the repetitive src="" and alt="" every time you use an img element? With PXSL's element defaults, you don't need to.

Using element defaults to create attribute shortcuts

Element defaults are shortcuts that are defined in a separate file using a simple syntax. (For the specifics of creating and loading these files, see the Reference section on pxslcc.) For example:

img = img src alt

This shortcut allows you optionally to leave off the -src= and -alt= part whenever you write the PXSL markup for an img element. For example, with this definition in place, all three of these PXSL statements mean the exact same thing:

img -src=/images/logo.png -alt=Logo img /images/logo.png -alt=Logo img /images/logo.png Logo

All of them convert into the same XHTML:

<img src="/images/logo.png" alt="Logo"/> <img src="/images/logo.png" alt="Logo"/> <img src="/images/logo.png" alt="Logo"/>

In other words, shortcuts let you pass attribute values by position instead of by the -name=value syntax. You provide only the values, and the shortcut provides the corresponding -name= parts behind the scenes.

But there are a couple of restrictions to keep in mind. First, attribute values passed by position must come first, before any values passed using the -name=value syntax, and they must occur in the same order as declared in the shortcut definition.

Second, you can only pass values this way if they do not contain whitespace. If a value contains whitespace, you must use the -name=value syntax and quote the value: -name=<<my value>> (There is an advanced feature, the <( )> delimiters, that overcome this restriction. They are described in the section on advanced macros, later in this document.)

Using element defaults to create virtual elements

You can also use the element defaults to create your own virtual elements. If you work in XHTML, you have probably noticed that the <a> element is used to create both hypertext links and anchors. For example:

<a name="anchor-name">Anchored text</a> <a href="#anchor-name">Link to anchored text</a>

Why not make these two uses more obviously distinct while cutting down on markup at the same time? Let's create virtual "anchor" and "hlink" elements that do just that:

anchor = a name hlink = a href

Now we can use these elements in PXSL to express the above XHTML more clearly:

anchor anchor-name <<Anchored text>> hlink #anchor-name <<Link to anchored text>>

(Notice that we used << and >> in an advanced way that lets us put quoted text on the same line as the element that contains it. This is discussed further in the "Advanced quoting" section.)

When we convert the above PXSL into XML, it results in exactly the same XHTML that we discussed earlier:

<a name="anchor-name">Anchored text</a> <a href="#anchor-name">Link to anchored text</a>

Making and using your own element defaults

Making your own shortcuts is easy. Just create a file that contains lines of this form:

element-name = preferred-element-name opt-attr-1 opt-attr-2 ...

It's a good idea to extend the file's name with a suffix of ".edf", which is short for "element defaults," but feel free to ignore this convention.

For example, we might create a "xhtml-shortcuts.edf" file to capture our shortcuts from above:

# File: xhtml-shortcuts.edf

anchor = a name hlink = a href

(Notice that a you can place comment lines in your .edf files by starting them with a "#" character.)

To use the shortcuts, tell pxslcc to --add them to the set of active element defaults that are used when processing your PXSL files:

$ pxslcc --add=xhtml-shortcuts.edf my-doc.pxsl > my-doc.xhtml

You can --add more than one set of defaults, and pxslcc will use them all.

Built-in element defaults for XSLT stylesheets

PXSL was originally created to reduce the verbosity of XSLT stylesheets. As a result, pxslcc has a built-in set of elements defaults for XSLT that you can enable by passing the --xslt flag:

$ pxslcc --xslt stylesheet.pxsl > stylesheet.xsl

The built-in defaults provide two benefits: First, you can use element names from within the XSLT namespace without having to use the xsl: prefix. Second, you can pass common required attributes like "select" and "match" by position.

Together, these benefits result in massive markup reductions, making your life as an XSLT author much easier. Compare the following snippet of XSLT in XML

<xsl:template match="/"> <xsl:for-each select="//*/@src|//*/@href"> <xsl:value-of select="."/> <xsl:text>
</xsl:text> </xsl:for-each> </xsl:template>

with the same snippet rewritten in PXSL (using --xslt defaults):

template / for-each //*/@src|//*/@href value-of . text <<
>>

Among the many XSLT shortcuts enabled by the --xslt flag, the above PXSL snippet uses the following:

template = xsl:template match name for-each = xsl:for-each select xml:space value-of = xsl:value-of select disable-output-escaping text = xsl:text disable-output-escaping

To see the complete list of XSLT shortcuts, --export them:

$ pxslcc --xslt --export

Advanced quoting with the `<<` `>>` and `<{` `}>` delimiters

XML quoting `<<` `>>` delimiters

The << and >> delimiters not only let you insert text into your PXSL documents, but also let you insert raw, full-featured XML. This works great for those times when it's just easier to write a bit of XML than its PXSL equivalent. For example, if you're writing an XSLT stylesheet that generates XHTML output, you'll certainly want to use PXSL to express the markup-dense xsl:stylesheet directives. But, if you need to drop in some XHTML boilerplate that a designer gave you to use in the page footer, just copy-and-paste it using << and >>:

Another great use for the << >> delimiters is to drop XML specials like processing instructions into your code:

<<<?xml version="1.0" encoding="ISO-8859-1"?>>>

The above PXSL is equivalent to the following XML:

<?xml version="1.0" encoding="ISO-8859-1"?>

Because the << >> delimiters quote XML, you must follow XML's syntactical rules when using them. That means that if you want to include literal less-than "<" and ampersand "&" characters, you must use character entity references:

<< less-than: < >> << ampersand: & >>

Verbatim text `<{` `}>` delimiters (CDATA)

When copy-and-pasting blocks of text from outside sources, you must be careful to "escape" any literal "<" and "&" characters that may be within. This can be annoying, especially for large blocks of text. Another place where this requirement is burdensome is in mathematical expressions that sometimes occur in XSLT markup:

xsl:test -when=<< $i < 5 >>

For this reason, PXSL provides the verbatim-text delimiters <{ and }> that perform the same function as XML's more verbose CDATA delimiters:

XML PXSL

<![CDATA[ toast & jelly ]]> <{ toast & jelly }>

Any characters that you place inside of <{ }> will come out as a character literals. PXSL will take care of any escaping that is necessary to prevent XML from misinterpreting your text as markup. For example, we can rewrite the above XSLT snippet more clearly using the verbatim-text delimiters:

xsl:test -when=<{ $i < 5 }>

These delimiters are especially handy for including examples of XML markup in your documents. Like << >>, <{ }> can handle large blocks of multi-line text and preserve whitespace and indentation.

Text-content shortcut

As you may have noticed from the MathML example at the beginning of this document, if an element contains text, you can declare the text on the same line as the element. This saves space and often reads more easily:

NORMAL SHORTCUT

h1 h1 <<Chapter 1>> <<Chapter 1>> h2 <{Sections 1 & 2}> h2 <{Sections 1 & 2}>

Macro facility

PXSL has a simple macro facility that you can use to reorganize your markup and "factor out" boilerplate. A macro is defined with a leading comma and a trailing equals sign, like so:

,name = body

where "name" is the name of the macro and "body" can be any series of elements and text. Macros can be defined at any level of nesting within a PXSL document, but they are only visible (i.e., available for use) at the level where they were defined and at levels nested underneath. (If two macros with the same name are visible at the same time, the deepest one will hide the other, or if both are on the same level, the one defined latest in the document will hide the earlier.)

Using macros (i.e., macro expansion)

To use a macro, simply refer to it by name anywhere that an element can be used:

,hello = <<Hello!>>

html head title ,hello body <<Hello! Again!>>

When processed with pxslcc (using the --indent flag), this is the result:

<html> <head> <title>Hello!</title> </head> <body>Hello! Again!</body> </html>

Note that the macro definition has been removed and that the reference to the macro inside of the "title" element has been replaced by the macro's body. This is called macro expansion.

Macros don't need to be defined before they are expanded, as long as they are visible from the sites (locations) where they are expanded. Also, macros can call other macros:

,hello = <<Hello!>>

html ,head ,body

,head = head title ,hello

,body = body <<Hello! Again!>>

This snippet results in exactly the same XML as the one above. Nevertheless, we have made a number of organizational changes. The "head" and "body" within the "html" element have been factored out into the macros ,head and ,body and relocated within the document. These macros are defined within the "html" element, after the sites where they are expanded. Note that the ,head macro calls upon the ,hello macro that we defined earlier.

Although contrived in this small example, factoring out blocks of markup makes the structure of large documents easier to understand and manage because you are free to move them around, subdivide them further, and reuse them in many locations.

Parameterized macros

Macros can take any number of parameters, which allows you to customize their definitions. For example, we could customize the definition of the ,head macro that we used above to accept the title as a parameter:

,make-head my-title = head title ,my-title

Now we can use it to create a head element that contains any title that we want:

,make-head -my-title=<<This is my title.>>

Note that we pass parameters to a macro just like we pass attributes to an element definition.

But what if we want to pass more than strings? What if we want to pass large sections of documents as parameters? We can do this using the special BODY parameter that all macros have:

,make-section title = section -- start of section title ,title ,BODY -- end of section

The BODY parameter accepts any content defined underneath the macro-expansion site (i.e., the body of the macro-expansion invocation):

,make-section -title=<<This is my title>> p <<This is a paragraph.>> p <<And another.>> p <<And so on.>>

The result of calling this macro is the following XML:

<section>  <title>This is my title</title> <p>This is a paragraph.</p> <p>And another.</p> <p>And so on.</p>  </section>

Advanced macros and passing parameters with the `<(` `)>` delimiters

As we showed earlier, one way of passing document fragments to macros is via the implicit BODY parameter that all macros have. Another is to pass them as normal arguments using the <( )> delimiters, which let you group PXSL document fragments into chunks that you can pass as arguments.

For example, let's redefine the make-section macro we defined above to accept the body of the section as a normal parameter:

,make-section title body = section -- start of section title ,title body ,body -- end of section

Now we can call it like so:

,make-section -title=<<This is my title>> \ -body=<( p <<This is a paragraph.>> p <<And another.>> p <<And so on.>> )>

(Note the use of the backslash in between parameters to continue the parameter list to the next line. This useful trick also works to continue attribute lists when you are creating elements.)

Because the <( )> delimiters can be used only to pass arguments, you can use them to "quote" arguments that otherwise could not be passed via position, e.g., a fragment of text that contains whitespace:

,make-section <( <<This is my title>> )> \ <( p <<This is a paragraph.>> p <<And another.>> p <<And so on.>> )>

You can even use the <( )> delimiters to pass the results of macro calls to elements and other macros:

,h1 x = -- level one heading h1 ,x

,bang x = ,x <<!>>

,h1 <( <<Hello, >> ,bang World )>

The above produces the following XML:

 <h1>Hello, World!</h1>

Insanely advanced macros and functional programming

(Warning: Programming language esoterica follows. Feel free to skip this section if you're not a language nut. I don't know whether you can find a use for this, but if you can, my hat's off to you.)

Not that we expect you to find any practical use for them, but in PXSL macros are first-class values that can be created, bound to parameters, and passed between macros. You can create anonymous macros using the familiar comma syntax -- just don't provide a name:

, arg = body

(Note the space between the comma and the start of the argument list.) To call an anonymous macro, of course, you'll first have to bind it to a name. The way you do this is to pass the anonymous macro to another macro, causing the anonymous macro to be bound to a parameter of the other macro:

,some-other-macro <( , arg = body )>

A more practical example:

,double str = <{"}> ,str <{"}> ,single str = <{'}> ,str <{'}> ,add-quotes quote-fn str = ,quote-fn <( ,str )>

-- let's quote a couple of strings

,add-quotes <( , x = ,double <(,x)> )> -str=<<Quote Me>> << >> ,add-quotes <( , x = ,single <(,x)> )> Please!

Pxslcc compiles the above into the following output:

"Quote Me" 'Please!'

In this example, the two calls to the ,add-quotes macro each pass in an anonymous macro that performs the desired quoting operation. The anonymous macro is bound to "quote-fn" when the ,add-quotes macro is called and expanded. Thus, when ,add-quotes calls ,quote-fn, it is really calling the anonymous macro that we passed to it. This lets us customize the behavior of ,add-quotes without having to rewrite it.

See "xsl-menus-w-macros.pxsl" in the examples directory for a good example of how anonymous macros can be used to factor out common code.

Automatic PXSL-to-XML conversion via Make

Most Make utilities allow you to define pattern rules that are then used automatically to convert one class of documents into another. Pattern rules can be used to automate the conversion of PXSL documents into their XML counterparts. For example, if you place the following rule into a makefile (this is for GNU make),

%.xml: %.pxsl pxlscc --indent=2 $< > $@

Make will automatically generate .xml documents from the corresponding .pxsl documents whenever they are needed. This frees you to substitute .pxsl documents anywhere that your project calls for .xml documents, knowing that make will keep all of the .xml documents up to date, regenerating them as needed when you update your .pxsl documents.

Reference: pxlscc

Usage: pxslcc [OPTION...] [file] -i[NUM] --indent[=NUM] Re-indent XML using NUM spaces per nesting level -h --header Insert edit-the-PXSL-instead header into output XML -x --xslt Add XSLT defaults -a FILE --add=FILE Add the given defaults file --export Export (print) all of the active defaults --dump Dump internal parse format (for debugging)

The --header option requires some explanation. It inserts the following header comment into the output XML:

<!--

NOTICE: This XML document was generated from PXSL source. If you want to edit this file, you should probably edit the original PXSL source file instead.

-->

It's a good idea to use the --header option all of the time. This prevents you (or somebody else) from accidentally editing an XML file when you really ought to be editing the PXSL file from which the XML file is generated.

[TODO: Expand this section]

Reference: PXSL syntax

The PXSL grammar, in EBNF-like notation:

pxsl-document ::= statement*, EOF

pxsl-comment ::= '#', all-text-until-newline, NEWLINE xml-comment ::= "--", all-text-until-newline, NEWLINE literal-constructor ::= mixed-literal | cdata-literal element-constructor ::= xml-name, posn-args, nv-args, children macro-def ::= ',', xml-name?, param-names, '=', macro-body macro-app ::= ',', xml-name, posn-args, nv-args, children

xml-name ::= ( LETTER | '_' | ':' ), ( LETTER | DIGIT | '_' | ':' | '.' | '-' )* posn-args ::= expr-list nv-args ::= ( line-continuation?, name-value-pair )* name-value-pair ::= '-', xml-name, '=', expr children ::= statement* /* must be indented */ macro-body ::= children param-names ::= ( line-continuation?, xml-name )*

line-contination ::= '\', newline

expr-list ::= ( line-continuation?, arg-expr )* arg-expr ::= expr /* cannot start with '-' */ expr ::= expr-single | NON-WHITESPACE+ expr-single ::= mixed-literal | cdata-literal | pxsl-fragment mixed-literal ::= "<<", all-text-until->>-delimiter, ">>" cdata-literal ::= "<{", all-text-until-}>-delimiter, "}>" pxsl-fragment ::= "<(", statement*, ")>"

Authors

Tom Moertel <tom@moertel.com> http://www.moertel.com/

Bill Hubauer <bill@hubauer.com>

(For Emacs)

Local Variables: mode:outline End:

Index of /pxsl/sources/pxsl-0.9.1

PARSIMONIOUS XML SHORTHAND LANGUAGE

Table of Contents

Getting PXSL

Getting help

LICENSE

Getting or building the PXSL tools

Gentle Introduction to PXSL

Why PXSL ?

A closer look at PXSL

Using PXSL documents

Advanced topics

Element defaults provide convenient, customizable shortcuts

Using element defaults to create attribute shortcuts

Using element defaults to create virtual elements

Making and using your own element defaults

Built-in element defaults for XSLT stylesheets

Advanced quoting with the << >> and <{ }> delimiters

XML quoting << >> delimiters

Verbatim text <{ }> delimiters (CDATA)

Text-content shortcut

Macro facility

Using macros (i.e., macro expansion)

Parameterized macros

Advanced macros and passing parameters with the <( )> delimiters

Insanely advanced macros and functional programming

Automatic PXSL-to-XML conversion via Make

Reference: pxlscc

Reference: PXSL syntax

Authors

(For Emacs)

Advanced quoting with the `<<` `>>` and `<{` `}>` delimiters

XML quoting `<<` `>>` delimiters

Verbatim text `<{` `}>` delimiters (CDATA)

Advanced macros and passing parameters with the `<(` `)>` delimiters