Home arrow XML arrow Page 4 - Using Script Extensions in Xalan-Java
XML

Using Script Extensions in Xalan-Java


This article will look at scripting languages that are not covered in the Xalan documentation, in particular, Python, VBScript, and PerlScript. In addition, we will show how Java Object instances, created in XSLT as part of the Java language extensions mechanism, are passed to these scripts and utilized by them. These samples will provide a solid foundation on which to build more complicated script-based extensions.

Author Info:
By: Seamus Donohue
Rating: 5 stars5 stars5 stars5 stars5 stars / 14
June 16, 2004
TABLE OF CONTENTS:
  1. · Using Script Extensions in Xalan-Java
  2. · Xalan-Java Scripting Extensions, Resources, Requirements
  3. · The Scripting Scenario
  4. · Plugging the Scripts into the XSLT Stylesheet
  5. · Python
  6. · VBScript
  7. · PerlScript
  8. · Running the Stylesheet

print this article
SEARCH DEVARTICLES

Using Script Extensions in Xalan-Java - Plugging the Scripts into the XSLT Stylesheet
(Page 4 of 8 )

Xalan enables script files to be imported from an external file or inserted in-line into the stylesheet directly. In the examples in this article, all scripts are stored in-line. Xalan supports multiple script types in the same stylesheet. However, each script type must be placed in a separate <component> element. A sample JavaScript component is shown below:

<lxslt:component prefix="javascript" elements="" functions="calculate_surname, calculate_firstname, calculate_bonus">

Function X declared in this script is then accessed via the XSLT fragment:

<xsl:value-of select="javascript:X( param1, param2, )"/>

Integrating and using Java-based script interpreters (for example, JavaScript and Jython) is relatively straightforward. Integrating Windows ActiveScript script support such as VBScript, Jscript, and PerlScript requires some additional configuration; JavaBean access is also slightly different with ActiveScript.

The following sections describe how JavaScript, Python, VBScript, and PerlScript are used to implement the scripting scenario.

JavaScript

The JavaScript support is based on Rhino version 1.5.

Configuration

Ensure that the js.jar file is in the classpath used by the XSLT processor.

Simple Function without a JavaBean Parameter

The function below shows how JavaScript regular expression support is used to calculate the output surname element using the input name element:

function calculate_surname( name )
{
 return name.split( /s/g )[1];  
}

The XSLT function call is:

<xsl:value-of select="javascript:calculate_surname( string(name) )"/>

Note that the name element is coerced into a string type before it is passed to the function. This will ensure that a string type rather than a node type is passed to the function.

Function with JavaBean Processing

The function below shows how JavaScript handles JavaBean parameters. This function must perform a table lookup in order to calculate the bonus awarded to a salesperson. Because the JavaScript interpreter is Java-based, the bean instance is passed directly to the script. This is not possible for script interpreters that are not Java-based, as we will see later when we discuss using Windows ActiveScript, which is based on C and C++.

function calculate_bonus( quota, actual, bonusplan, bonus_table )
{
 /* find base bonus from lookup table */
       var bonus_base = parseFloat( bonus_table.lookUp(bonusplan,1), 10 ) ;
               
      /*calculate multiple, bonus multiple is zero if they underperform */
       var multiple = (actual > quota) ? actual/quota : 0 ;
               
      return bonus_base * multiple;
}

The bonus_table.lookup operation returns a string that must be explicitly converted to float, because JavaScript is a strongly typed language. The rest of the script calculates the sales success (the multiple value) and returns the bonus award calculation as the bonus_base (from the table) multiplied by multiple.

The XSLT function call is as follows:

<xsl:value-of select="javascript:calculate_bonus( number(quota), number(actual), string(bonusplan), $bonus_table )"/>

Again, note that parameters are converted to XSLT number and string types, where required, before they are passed to the JavaScript (the XSLT number type is mapped to a Java double type). This is good practice, because it will keep strongly typed scripts from having to coerce values to the correct type before processing them. The bonus_table variable is passed as is.

Next: Python >>

blog comments powered by Disqus
XML ARTICLES

- Open XML Finally Supported by MS Office
- XML Features Added to Two Systems
- Using Regions with XSL Formatting Objects
- Using XSL Formatting Objects
- More Schematron Features
- Schematron Patterns and Validation
- Using Schematron
- Datatypes and More in RELAX NG
- Providing Options in RELAX NG
- An Introduction to RELAX NG
- Path, Predicates, and XQuery
- Using Predicates with XQuery
- Navigating Input Documents Using Paths
- XML Basics
- Introduction to XPath

Watch our Tech Videos 
Dev Articles Forums 
 RSS  Articles
 RSS  Forums
 RSS  All Feeds
Write For Us 
Weekly Newsletter
 
Developer Updates  
Free Website Content 
Contact Us 
Site Map 
Privacy Policy 
Support 

Developer Shed Affiliates

 




© 2003-2017 by Developer Shed. All rights reserved. DS Cluster - Follow our Sitemap
Popular Web Development Topics
All Web Development Tutorials