CA2484355A1

CA2484355A1 - System and method for transformation of xml documents using stylesheets

Info

Publication number: CA2484355A1
Application number: CA002484355A
Authority: CA
Inventors: Kevin J. Jones
Original assignee: Sarvega, Inc.; Kevin J. Jones; Intel Corporation
Current assignee: Intel Corp
Priority date: 2002-05-02
Filing date: 2003-05-02
Publication date: 2003-11-13
Also published as: US20040010754A1; US7480856B2; WO2003094007A1; AU2003231305A1; EP1502196A1; EP1502196A4; AU2003231305B2

Abstract

A method and apparatus are provided for creating and abstract machine instruction sequence from one or more stylesheets (12) and using this sequence to perform a transformation on one or more input documents (20). The method includes the steps of parsing the stylesheet and compiling it into the sequence of abstract machine instructions. The instructions are executed an the abstract machine (18) with input document(s) (20) to produce one or more output documents (22). More particularly, the method is directed to processing one or more XML documents (20) where the processing includes a plurality of stylesheets (12) using an abstract machine (18). The method includes the steps of reading a stylesheet (14) of the plurality of stylesheet (12), compiling the stylesheet (16) into a set of abstract machine instructions specialized for stylesheet processing and executing the instructions on the abstract machine (18).

Description

SYSTEM AND METHOD FOR TRANSFORMATION OF XML DOCUMENTS USING
STYLESHEETS
Field of the Invention [0001] The field of the invention relates to the transformation of XML documents, specifically the use of a stylesheet to describe the transformation to be performed via an abstract machine.
Background of the Invention

[0002] Extensible Markup Language (XML) is a standardized text format that can be used for transmitting structured data to web applications. XML offers significant advantages over Hypertext Markup Language (HTML) in the transmission of structured data.

[0003] In general, XML differs from HTML in at least three different ways. First, in contrast to HTML, users of XML may define additional tag and attribute names at will. Second, users of XML
may nest document structures to any level of complexity. Third, optional descriptors of grammar may be added to XML to allow for the structural validation of documents. In general, XML is more powerful, is easier to implement and easier to understand.

[0004] However, XML is not backward compatible with existing HTML documents, but documents conforming to the W3C HTML
3.2 specification can be easily converted to XML, as can documents conforming to TSO 8879 (SGML).

[0005] A transformation process can be applied to a XML
document to convert it from one XML format to another. Commonly the description of the transformation is contained with a second document, a ~~stylesheet". The transformation operates on one or more input documents and produces one or more output documents.

[0006] While existing methods of processing XML documents work relatively well, the ability to nest to any level of complexity and the optional description of grammar has resulted in processing structures that consume large amounts of memory and are, consequently, relatively slow and inefficient. Because of the importance of structured data, a need exists for a method and apparatus that is specifically structured to the needs of processing XML documents.

7 PCT/US03/14017 Summary [0007] A method and apparatus are provided for processing a stylesheet into an executable form and the execution of that form to create the transformed documents. The executable form is a set of abstract machine instructions specialized for performing the transformation operation. These instructions are.executed on an abstract machine against a number of input documents to create output documents.

[0008] More particularly, the method is directed to processing one or more XML documents where the processing includes a plurality of stylesheets using an abstract machine. The method includes the steps of reading a stylesheet of the plurality of stylesheets, compiling the stylesheet into a set of abstract machine instructions specialized for stylesheet processing and executing the instructions on the abstract machine.
Brief Description of the Drawings

[0009] Fig. 1 is a block diagram of a system for processing XML documents with stylesheets using an abstract machine under an illustrated embodiment of the invention;

(0010] Fig. 2 is a block diagram for the Abstract Machine based stylesheet processor program that may be used by the system of Fig. 1;

[0011] Fig. 3 is a block diagram for the Abstract Machine Compiler program that may be used in conjunction with the system of Fig. 1;

[0012] Fig. 4 is a block diagram for the Abstract Machine program that may be used in conjunction with the system of Fig. 1.
Detailed Description

[0013] Fig. 1 depicts a system 10, shown generally, under an illustrated embodiment of the invention for processing one or more XML documents 20 with one or more stylesheets 12 using an abstract machine that executes abstract machine instructions 24 compiled from the stylesheets. As used herein, a representation of a stylesheet may be an XSLT stylesheet conformant to the W3C XSL
Transformation standard. The representation of a stylesheet may also be conformant to W3C XQuery and XPath standards.

[0014] As shown in Fig. 1, the system 10 reads stylesheets 12 and transforms XML Input Documents 20 into Output Documents 22.

Within the system 10, the Read Stylesheet Processor 14 may first read the stylesheets. A Compile Stylesheet processor 16 may analyze and compile the stylesheets into a set of abstract machine instructions 24. The Abstract Machine processor 18 executes the abstract machine instructions and processes the XML input documents 20 to generate the corresponding output documents 22.
[0015 Fig. 2 is a simplified block diagram of FIG. 1 showing the program structure for an abstract machine based stylesheet processor. The Stylesheet(s) 100 are converted by an Abstract Machine (AM) Compiler 200 into a set of Abstract Machine (AM) instructions 700. These instructions are executed on the Abstract Machine 300 that processes XML Input Documents 500 to create one or more Output Documents 600. The Abstract Machine may also use a Runtime Library of functions 400 to assist in performing the AM instructions. The output documents may be XML documents, HTML
documents or plain text documents depending on the requirements of the transformation.
[0016 In general, before an XSLT stylesheet may be executed on the Abstract Machine it may first be compiled by an Abstract Machine Compiler into Abstract Machine (AM) instructions.
The compilation process may include a number of processing steps.
As a first step, each stylesheet may be loaded into memory in a tree data structure. Next, the data on the tree nodes may be analyzed and annotated with additional information. Next, for each global variable in the tree AM instructions may be generated. Finally, for each template in the tree, AM instructions may be generated.
[0017] The annotated tree may be converted into AM
instructions via recursive descent processing of the tree nodes.
Contained within the annotated tree nodes are XPath expressions that may also be compiled into AM instructions. Each XPath expression is compiled (recursively) into AM instructions in a very ,similar way to that process used for stylesheet instructions. For example, each expression may be parsed into a tree structure. Next, the data in the trees nodes may be analyzed and annotated with additional information. Finally, the AM instructions are generated from the annotated parse tree.
[0018] It should be noted that each processing step described herein (or shown in the drawings) is associated with a subroutine (i.e., a physical processing element and processor) that accomplishes that step. Accordingly, each processing step described herein has a corresponding processor adapted to accomplish that step.
[0019] Fig. 3 is a block diagram that may be further used to describe the program structure of the Abstract Machine Compiler 200 (Fig. 2). The block "Load Stylesheets 100" (Fig. 3) functions to load the stylesheets into memory as a Stylesheet Tree 200 data structure. The next block, "Analyze Stylesheet 300" (Fig. 3) functions to analyze the Stylesheet Tree data structure and annotates it with additional information for stylesheet (XSLT) instructions found in it. The result of the analysis is output as the Annotated Stylesheet Tree 400 data structure.
[0020] The next block "Generate AM Instructions 900" (Fig.
3) functions to recursively descend through the Annotated Stylesheet Tree data structure and generates AM Instructions 1000 for each stylesheet instruction. AM instructions are generated for each global variable, template and stylesheet instruction in the tree. It also invokes Parse XPath Expressions 500 and Analyze XPath 700 processes for each XPath expression encountered in the tree. The block Generate AM Instructions 900 recursively descends through the Annotated XPath Tree 800 data structure generated by Analyze XPath and generates AM instructions for the XPath expression.
[0021] The process of the block Parse XPath Expression 500 functions to parse the XPath expression in the Annotated Stylesheet Tree data structure and generate the XPath Tree 600 data structure.
The Analyze XPath 700 process functions to analyze the nodes in the XPath Tree and annotates the nodes with additional information for the XPath components found in it.
[0022] Data types will be considered next. XSLT and XPath share a common type system that has five basic data types, strings, numbers, booleans, nodesets and result tree fragments. The AM 300 (Fig. 2) is designed to be almost completely indifferent as to data type (i.e., it is type agnostic). That is, it implements only a minimal amount of functionality to support the use of the XSLT and XPath type system. By implication, the AM Compiler 200 (Fig. 2) has to be capable of performing type analysis on a XSLT stylesheet and emitting AM instructions 700 (Fig. 2) that require no type support from the AM 300 (Fig. 2) implementation. For example, string values are represented via a character pointer stored as 32 bit unsigned integer. AM instructions may directly operate on this value but they contain no assumptions that this value is a character pointer; it could equally be used to store a Boolean value.

[0023] Where typed data operations are required in the AM
300 (Fig. 2), they are implemented as external routines in the Runtime Library 400 (Fig. 2) that may be invoked by the AM. An example of such a function might be to compute the length of a string. This function can be invoked by the AM at any time but would only produce correct results if it were indeed passed a character pointer value. Passing the wrong data type to external functions results in undefined behavior.
[0024] XSLT processors have historically used runtime data type analysis. In a runtime typed system, the type of a data value is encoded with the data value so that correctly typed operations may be determined as the value is processed. The use of static type analysis has a number of advantages over such a scheme. First, the compiler can generate simpler instruction sequences by exploiting information about the types of data values used in operations.
Second, the abstract machine does not need to perform runtime type checking operations and third, memory requirements for data storage can be pre-calculated by the compiler allowing for simpler data storage routines.
[0025] The main disadvantage of using statically typed data is that there is no protection against errors in the AM
compilation process. An AM compiler error will result in undefined behavior but the combined effect of the advantages is that it allows for both a simpler and higher performance implementation.
[0026] One complication in XSLT static type analysis is that parameters passed to templates (similar to function arguments) are un-typed. This is because it is not possible in XSLT to statically determine a call graph for the templates used in a stylesheet. The call graph varies depending on the schema of the input documents and other factors.
[0027] In the AM Compiler 200 (Fig. 2), this issue is handled by using a special ANY type that acts as the union of the five primitive types. When an ANY type is used in an expression, runtime conversion functions are applied to convert the value to a primitive type as needed. If no conversion is possible, a runtime error is generated. The AM is not aware of the use of an ANY type just as it is not aware of the use of other primitive types; it's entirely a compiler issue. In this respect the ANY type acts as an AM independent runtime type fallback mechanism.
[0028] Type analysis will be considered next. The AM
Compiler 200 (Fig. 2) has to determine the type of each expression used in a stylesheet since the AM 300 (Fig. 2) is type agnostic.
XSLT expressions are always formulated using a related language called XPath. There are only two mechanisms where XSLT instructions create data values that must be stored for other instructions, variables and parameters. In both of these cases, data types can be determined by analysis of the variable or parameter declarations. As mentioned earlier, it is not possible to determine the type of a parameter at its point of use. In these cases the AM Compiler uses the ANY type also described earlier.
[0029] Type analysis for XSLT is therefore a special case of type analysis for XPath. As described earlier, a tree of nodes (XPath Tree 600 in Fig. 3) is used to represent each XPath expression after it has been parsed from its string form. Analyze XPath 700 (Fig. 3) recursively descends through the XPath Tree data structure and creates Annotated XPath Tree 800 with type and other additional information. Each node in the tree is annotated with the type of value it will generate when executed. For each node, the data type of the value of the contained expression can be determined via a combination of any input values and the nature of the operation. For example the XPath '~' (union) operator always returns a value of type nodeset. For all possible XPath expressions it is possible to determine the type of value the expression evaluates to.
[0030] There are two cases where context information from outside the expression is required in determining the type of an expression. These are where variables or parameters are used within the expression. To resolve this ambiguity, an input to the annotation of the XPath type analysis step in Analyze XPath 700 (Fig. 3) is a set of parameters/variables and the data types that they will generate when evaluated. This set is pre-computed using the same type analysis algorithm but applied to the expression used to formulate the parameter or variable. For example, the expression, concat ( 'xx' , $p+c~id) is parsed into the following tree structure, Operation 'concat' Argl:
String 'xx' Arg2:
Operation '+' Argl: $p (Assume parameter, i.e. ANY type) Arg2: Node expression Rewriting this to show the types provides the result as follows:

concat(string('xx'), any($p)+nodeset(Qid)).
[0031] The AM instructions 1000 (Fig. 3) are generated by a recursive descent algorithm being applied to the type annotated tree (Annotated XPath Tree 800 in Fig. 3). The AM instructions generated at the visit of each node in the tree vary with the type of node being visited. In general form, they normally cause the AM
instructions to be generated for any sub tree before adding AM
instructions that implement the operation of the node.
[0032] In the example case given above, it is known a prior that the result of evaluating each argument must be a string value, it is also known that the '+' operator may only be applied to two number values. Thus the expression can be re-written into the following form to indicate implicit type conversions that would be added during the compilation process.
concat('xx',string(number($p)+number(string(c~id)))) [0033] The expression is not actually rewritten into this type correct form, but the Generate AM instructions 900 process (Fig. 3) inserts type conversion AM instructions as required as though this form had been used in place of the original expression.
[0034] For the example XPath expression "concat('xx',$p+~id)", following are a set of AM instructions that would be generated by the block Generate AM Instructions 900 (Fig.
3) as though the expression has been rewritten with implicit type as above.
382 push data~tr 3 (xx0 ...) // Push string 'xx' onto stack 393 push_stack 0,3 // Push $p onto stack 405 number any // Convert $p to a number 409 reset 5 // Search for Qid 417 try 457 425 match attribute S::id 441 limit 1 449 collect 5 457 front 5 // Extract first matching Qid 465 string node // Convert oid to string 469 number_string // Convert string to number 473 extern 269091114(Number+Number)// Add number(Qid)+$p 481 string number // Convert result to string 485 push data 1 (2 0 0 0 ...) // Push 2 onto stack (arg. count) 497 extern 269077884(Concat) // Call concat [0035] The Abstract Machine will be considered next. The Abstract Machine (AM) 300 (Fig. 2) implements an instruction set for performing transformations. As discussed in the previous section, a compiler is used to generate the instruction sequence to be executed. This section focuses exclusively on the method used to execute those instructions. Only the aspects of the abstract machine sufficient to describe the claims has been included, other aspects are excluded so as not to obscure the inventive concepts.
[0036] Fig. 4 is a block diagram of the program structure for Abstract Machine 300 (Fig. 2). The Evaluate AM Instructions 100 process reads the instructions from AM Instructions 200 and executes them. The instructions use state and information maintained using registers in AM State 900, data in Code Stack 800, Heap Stack 1000, Transform Allocator 500 memory areas; traverse through the nodes in the 2nput Tree 400 data structure corresponding to the Input XML
Documents 1100; and transform the input to produce Output Documents 700. The instructions may invoke Load Input XML Document 300 process to load Input XML Documents into Input Tree 400. The instructions may also invoke external routines contained in the Runtime Library 600.
[0037] Memory management may be considered next. A key issues in the design of an abstract machine is how to manage dynamic memory usage. It is common practice to allocate and release dynamic memory as required via general-purpose memory allocation libraries.
General purpose libraries provide good flexibility in memory usage but have significant performance penalties. In the AM, three types of contiguous memory storage may be used to match the requirements of stylesheet processing, the code stack 800, the heap stack 1000 and the transform allocator 500 (Fig. 4).
[0038] The code stack 800 (Fig. 4) is a traditional programming language stack used to hold template (function) activation records, local variables and intermediate computation results. The heap stack 1000 (Fig. 4) is used to store variable length data items such as strings and lists that cannot be assigned space on the code stack at compile time. It is termed a stack as it gets reset at the end of each XSLT template invocation but in other ways it acts as a heap during a template invocation.

[0039] The final storage type is the transform allocator 500 (Fig. 4). The transform allocator is a persistent store for the period of a transform. It is used primarily to store result tree fragments (also known as temporary trees) that may be constructed across many template invocations.
[0040] By using just these three memory areas it is possible to perform XSLT transforms without the need to use general-purpose memory allocation routines. This model has a number of significant advantages over the use of general-purpose memory allocation routines. The first advantage is that allocation is very efficient. Allocation requires just a single pointer to be incremented normally via a single machine instruction.
[0041] The second advantage relates to memory release. At the end of each template invocation the stacks can be 'rolled back' to the state at the start of the template invocation normally with a single machine instruction.
[0042] Another advantage relates to reducing processing threads. As used herein, there is no need to perform multi-threaded locking to allocate memory as the memory areas are specific to an individual transform and hence to a single thread.
[0043] Additional advantages accrue due to reduced memory access times. The memory areas used herein exhibit good locality of reference, i.e. memory used at similar times is stored closely together allowing the CPU cache to improve access times.
[0044] Further, errors are reduced. As far as possible, the details of how and where memory is being used are hidden by the AM instructions thus limiting scope for memory management errors.
[0045] A description of the code stack 800 will intentionally be delayed until later when template invocation is discussed in detail. The next two sections describe the management of variable length data on the heap stack and transform persistent data on the transform allocator.
[0046] Variable length data saved in the heap stack will be considered first. The two most common data values used in a XSLT
program are Strings and Nodesets. Both of these data types represent variable length data values in that each String or Nodeset is made up of a variable number of smaller elements (characters and nodes respectively). The heap stack 1000 is designed explicitly to enable this type of data to be stored easily by the AM (Fig. 4).
[0047] Data elements can be added and removed from the heap stack as is common with all heaps. Variable length data is stored in sequential locations from some start position. Pointers to the start and optionally to the end of the variable length data are maintained by the AM instructions, normally as part of the Code Stack 800.
[0048] Traditionally this type of arrangement presents problems where support is required for the updating of multiple variable length data structures. In these cases, there is the possibility of interleaving of data on the stack resulting in corruption of data values. This issue is resolved in the AM
instructions by using an end pointer to the data that indicates the last valid memory address for a variable length data sequence. When a new value is added it is always placed in the location indicated by the end pointer rather than at the current stack limit.
[0049] Variable length data operations are compiled by the AM in such a way to guarantee that all operations on a single variable length structure are strictly nested. For example, given two variable length data values being computed (d1 and d2), the AM
allows some part of dl to be generated before d2 is used. Once d2 is no longer required operations can continue on d1 without corruption.
In pseudo code one could write, Data d1 For(i=0; i<10; i++) Dl.add(i);
Data d2 For (j=0; j<10; j++) D2.add(j) [0050] This would require storage space of 20 values on the heap but at no time will the values of dl and d2 be corrupted since d2 is only valid within a scope where d1 is not being changed.
When the length of variable length data value is known and fixed at the time it is placed on the heap stack there is no need to maintain an end value as that is only required for values that can be extended.
[0051] It is entirely the responsibility of the AM
compiler 200 (Fig. 2) to make sure that the instructions generated that use the heap stack do not violate the nesting model. The behavior of the abstract machine is undefined if the instruction sequence does violate this requirement.
[0052] The Transform Allocator will be considered next.
The problem of determining the call graph for a transformation makes it impossible to analyze the lifetime of all data structures used during a particular transform. As a fallback mechanism, a special purpose allocator is provided to allow memory to be allocated for the duration of the current transform. Memory allocated this way has the advantage of being valid for the remainder of the transform.
However because the memory is not released until the end of the transform, excessive use of the transform allocator can result in large overall memory requirements for a transform.
[0053] The transform allocator 500 (Fig. 4) obtains memory blocks from the general-purpose memory allocator. Parts of each of these blocks are used to provide storage for data structures created during the transform. Obtaining memory in blocks allows the cost of using the general purpose allocator to be amortized over a number of data structures at marginally greater memory usage.
[0054] The primary use of the transform allocator is in creating result tree fragments (or more descriptively temporary trees). Each temporary tree is in-memory representation of an XML
document.
[0055] Node Instructions and Backtracking will be considered next. One of the most commonly used data types in XSLT
is a nodeset. While the AM 300 (Fig. 2) design tries to avoid understanding data types, it does make an exception for nodesets and by implication node data types. Nodes have a special place in the AM
because they are fundamental to the XSLT/XML processing model.
Without nodes you could not have a XSLT processor but you could use XSLT without the other types although it would look quite different.
[0056] Much of the work of a XSLT processor is in evaluating path expressions that search an XML node tree for matching nodes. There are many ways in which such searches can be implemented but the AM has a specific need for performing depth first searching to allow the input XML to be demand loaded. With demand loading, an XML input document 500 is read and parsed in chunks as needed by the AM 300 (Fig. 2). Using breadth first searching techniques would cause the whole document to be loaded at the start of the first search. The depth first model allows loading to be delayed up until the depth first searching algorithm actually needs the data.

[0057] As a special case, it is sometimes necessary to employ a breadth first search model to enable the size of the result set to be calculated and used as part of the search. This model is only employed by the AM compiler 200 when needed as determined by the requirements of the search being performed. In either case, the AM instructions used for depth first searching can efficiently be used for breadth first searching if that is required.
[0058] Depth first searching can be implemented easily using a set of recursive functions calls, but that introduces an overhead for each call. In the AM 300 (Fig. 2) a similar approach is achieved via backtracking instructions.
[0059] Backtracking instructions have the unusual semantic that either they pass with the instruction pointer moving to the next instruction or they fail with the instruction pointer moving backwards to the last backtrack instruction. When the instruction pointer backtracks to an instruction it can either pass, by generating a new result, or fail with the instruction pointer moving backwards to the last backtrack instruction. The instructions can thus be said to be non-deterministic. That is: given some defined and constant input parameters, the instructions may return different results depending on some internal state stored in memory.
[0060] Using a sequence of such instructions thus implicitly performs a depth-first recursive search of some space.
For example, the XPath expression 'a/b' means search for all the children of the 'a' nodes (where a is a child of the starting node) that are called 'b'. In AM instructions 700 (Fig. 2) this translates to:
Match child 'a' Match child 'b' [0061] Execution starts by finding the first child node of the start node that is called 'a'. Execution then continues at the second instruction that searches for all the children called 'b'.
Once these have all been found, execution backtracks to the first instruction which searches for the next 'a'. If one is found, then execution continues searching for the child 'b' nodes.
[0062] It should be noted that using a smaller number of instructions is a desirable benefit of employing backtracking instructions. AM implementations contain a small performance overhead for each instruction executed. The smaller the number of instructions used to implement a search, the smaller the overhead.
[0063] In practice this code is too simplistic to do anything useful, to extend it slightly to store the results we might use the following.
Try 10 Match child 'a' Match child 'b' Collect 2 : ...
[0064] The try instruction is a form of single shot goto statement. When executed, the instruction pointer is incremented as normal to the next instruction. If the instruction pointer backtracks to this instruction, then it performs a jump forward using the offset in the operand., i.e. 10. The collect instruction stores the current node value in a sequence stored at the passed offset within the current stack frame. So, as a result, this sequence evaluates the expression 'a/b' and stores the results in a sequence stored at offset 2 from the current stack frame. The storage space for the sequence is in a block that is reserved for local variables for the current template.
[0065] In this section we do not describe how state is maintained during these instructions. This is detail that is generally not relevant to anyone generating AM instructions. However to complete the picture, backtracking information is stored on the code stack 800 (Fig. 4) in a similar way to which function frames are implemented in traditional programming languages. The AM State 900 data structure maintains the current state of the Abstract Machine in a set of registers, such as the next instruction pointer within AM Instructions 200 in IP, the backtracking pointer that points to the instruction activation record on the Code Stack in BP, the current Code Stack 800 pointer in SP, the current Heap Stack 1000 pointer in HP, the node context information within the Input Tree 400 data structure including the current node in NP, the node position in RP, the stack frame pointer that points to the start of the Code Stack frame for the current block in SPF, etc. Each backtracking instruction adheres to a set of conventions that ensures it can restore the state it had when it last completed execution and can therefore continue from where it last finished to generate extra results. A description of the processing performed by a backtracking instruction is given in a later section.

[0066] Although the AM 300 (Fig. 2) is highly dependant upon backtracking instructions for searching, in other areas it uses a more traditional instruction set. For example to print the string value of each node one could write, Try 10 Match child 'a' Match child 'b' PushNP
External "Node->String"
OutputPushStr Return [0067] In this case, a push instruction (PushNP) is used to transfer the current Node pointer to the Code Stack 800 (Fig. 4) before calling an external function (External "Node->String") in Runtime Library 600 (Fig. 4) that converts the pointer to a string, and then using an output instruction (OutputPushStr) that generates output from this string. These three instructions don't use backtracking but equally they don't disturb the backtracking process so that they can be used in an inline fashion. The return statement is similar to the collect instruction seen earlier but in this case it just forces backtracking without saving the current node.
[0068] Path Instructions may be considered next. The AM
supports a set of instructions for dealing with Node path searches and the sequences that are created as a result. Below is brief summary of these AM instructions.
Table 1 Summary of path and node related AM Instructions Match <axis> Perform a node search from the context [<mask>] [<uri>] node using [<name>] the <axis>. Nodes must match <mask>, a node type bitmap, <uri> and <name> if any is specified.

Reset <seq> Set the sequence <seq> to be empty Collect <seq> Store the context node in seq.

Replay <seq> Step through the nodes in seq.
ReplayOrdered Step through the nodes in seq after sorting <seq> into document order.

Count <seq> Count the nodes in the sequence.

Front <seq> Get the first node in the sequence SetRoot Set the context node to be the document root node SetCurrent Set the context node to be the current node Limit <uint> Only allow the node at position <uint>
to pass [0069] Blocks and Templates may be considered next. The instructions in a XSLT stylesheet are grouped into templates. Each template can be thought of as being similar to a function in a procedural programming language. Templates can be invoked in one of three ways: 1) Pattern Matching, 2) By Name and 3) By Import. The first, Pattern Matching, may be accomplished as the result of the XSLT processing model operating on the input. The second, By Name, may be accomplished as an effect of an instruction provided from inside some other template. The last, By Import, may also be accomplished as an effect of an instruction provided from inside some other template.
[0070] To support these different usage models, the AM 300 (Fig. 2) provides direct support for the concept of a block. An AM
block is a collection of instructions that were compiled together to use a common stack frame. In practice this means that inside a block you cannot make reference to the variables and temporary values of the calling block, only the data values of the current block. Each template is compiled as a separate block but so are some other XSLT
constructs such as parts of pattern matches.
[0071] The start of a block is indicated by a Block instruction that establishes a new stack frame pointer and reserves space on the stack for locals and temporary values. Blocks are backtracking instructions so the end of a block is marked by a return instruction. Taking the earlier example, one can place it in a block by writing, Block 2 Try 12 Match child 'a' Match child 'b' Collect 0 Return 12 Count 0 External Number->String OutputPushStr Return [0072] In this case, space for two 32-bit values is reserved when the block is entered for storing the sequence. Once we have generated the sequence, the following instructions starting at offset 12 are executed to convert this to a string to be output. The final return statement causes execution to return to the caller of the block.
[0073] A side effect of using blocks is that upon exit the Code Stack 800 and Heap Stack 1000 (Fig. 4) are unwound to be at (i.e., returned to) the same position when the block was called. In essence, all blocks are side effect free with respect to the Code Stack and Heap Stack.
[0074] There are four ways that a block may be called.
The first method is via a pattern match instruction which finds a matching template for a node. The second is via a direct call instruction used to call a named template. The third is via a pattern match for imports which calls a template that can match with a lower import precedence than the current template and the last is via an external function calling a well known block to perform part of its work.
[0075] The final case of execution of a well-known block is used to allow external algorithms to use the facilities of the abstract machine. A good example of this is the XSLT pattern matching process. Pattern matching requires the use of very specific algorithms to achieved high performance. While support for these algorithms could be implemented as AM instructions, there is little benefit as they are so specialized. Instead, pattern matching is implemented via external routines within Runtime Library 600 (Fig.
4) with one AM instruction used to invoke them. As part of the process of performing a pattern match, it may however be necessary to execute an XPath expression, something the AM is optimized to perform. To achieve this, additional 'well-known' blocks are created in the AM machine instructions for a stylesheet whose sole purpose is to be called by an external routine when needed.
[0076] Stylesheets execution starts by executing a bootstrap block. This evaluates global variables and performs the initial pattern match for the root node. This is not actually required as execution can start anywhere in the instruction sequence but it will always be the case for a compiled stylesheet.
[0077] One issue to point out is that at the end of execution involving backtracking instructions, the AM instruction pointer will jump backwards until it reaches the starting block. It will then try and backtrack from here but there is of course no parent block. To allow this situation to be detected, there is a dummy backtrack frame inserted at the top of the stack that sets the instruction pointer to 0. This is detected by the AM 300 (Fig. 2) interpreter code and treated as an instruction to terminate execution. Further detail on how backtracking instructions, such as blocks, are implemented in the AM will be provided later.
[0078] Instruction Backtracking Implementation will be considered next. The method used for backtracking instructions is key to how the Abstract Machine 300 (Fig. 2) implements both tree searching and template/block invocation strategies. Both methods employ backtracking instructions as the primary control flow mechanism.
[0079] The AM uses a number of internal registers and the code stack to maintain state between backtracking instructions. The primary registers maintained within AM State 900 (Fig. 4) involved in backtracking are the instruction pointer (IP) and the backtrack pointer (BP). The IP always points to the currently executing instruction within AM Instructions 200, while the BP points to an instruction activation record. The instruction activation record records the IP of the previous backtracking instruction and the BP
that was active when that instruction was invoked. All activation records are stored on the Code Stack that can be referenced via the register SP.
[0080] The instruction activation records thus form a chain in the stack. The process of backtracking is really a matter of taking a step back in that chain to recover previous IP and BP
values. The recovered BP value indicate where the next record in the chain can be located. This scheme is similar to that employed by the code generated by many compilers although it typically only applies to function/procedure calls whereas in the AM it can also be applied to individual instructions.
[0081] There are a few common patterns used by backtracking instructions that illustrate how this scheme is used in practice. The following sections show example code for these patterns.
[0082] To create a new frame, this would typically be followed by a change to the IP, normally to move on one instruction.
PUSH(BP) // Save BP on stack PUSH(IP) // Save IP on stack Bp=Sp // Save location of the record in BP
This sets the correct IP and SP so the backtracked instruction can restore its state.
To backtrack, Ip=*(Bp_1) // Set IP to value stored in record SP=BP // Restore the stack [0083] To determine if an instruction has been backtracked, the IP of the current backtrack frame can be checked against this instruction. If they match then this instruction was reached through backtracking.
*(BP-1)==IP // Compare IP values [0084] While these operations are sufficient to implement a simple backtracking scheme in practice, it is also necessary to save additional information in the activation record. In the AM, the current node pointer (NP) and node position (RP) are always saved for all backtrack instructions. For some instructions, additional state information is also saved on the stack but it is always done in a way that is compatible with the standard backtrack frame, i.e.
all frames have the same starting form of IP, BP, NP, and RP. This is followed by instruction specific state information.
[0085] As an example of this model, below is annotated code for implementing a Match-self AM instruction. This instruction either matches some condition (see MATCH) on the current node or fails by backtracking.
OpMatch* i=(~pMatch*)ip;// Get access to instruction operands if (!ISBACKTRACK()) // Is this the first time here ~

if (MATCH(i,np)) f // If current node matches test PUSH(rp); // Create backtrack frame on stack PUSH(np);

PUSH(bp);

PUSH(ip);

bp=sp; // Save location of backtrack frame rp=1; // Reset node position ip+=sizeof(OpMatch); // Move to next instruction } else BACKTRACK(); // Failed match so just jump back }
} else CHECKIP(); // We backtracked to here. There is no PQPUP(bp); // way for a second attempt as this is POPN(np); // a match self so just restore saved POPU(rp); // state and backtrack.

BACKTRACK();
}

[0086] It should be clear that the Block AM instruction can be simply constructed as a basic backtracking instruction as above. That is, when a Block instruction is executed, a new backtracking record is added to the stack. This ensures that when the instructions within the block complete execution, control is returned to this block instruction. When a Block instruction is backtracked to it simply invokes another backtrack to return control to the caller of the block. The Block instruction performs additional steps in reserving space on the stack (by incrementing the code stack pointer) and restoring the stack & heap pointers on backtracking thus releasing any memory used by the instructions inside the block.
[0087] A Summary of relevant AM Instructions will be provided next. The following table summarizes AM Instructions that are relevant for stylesheet processing. Note that this is not a complete set of all AM instructions. It should also be noted that the AM instructions relevant to stylesheet processing of Table 2 are specialized for stylesheet processing based upon the use of such features as depth first searching and backtracking. Table 2 lists the name of the AM Instruction in the first column, brief description of the instruction in the second column and whether the instruction is a backtracking instruction (Y) or not (N) in the third column.
Table 2 Summary of AM Instructions relevant for stylesheet processing Block , Start a new block Y

Return Unconditionally backtrack Y

Quit Terminate execution N

Error Report error N

Messa a Dis lay messa a on console N

Try Jum to an offset on backtrackin Y
Tree Create a temporary tree to re lace Y
current output destination Reset Set a nodeset to be empty N

Collect A end the context node to a nodeset I' Re la Cause iteration over a nodeset Y

Replay orderedCause iteration in node order of a Y
Re lay tree nodeset Y
Count Cause the re la of tree as though N
each node in the tree was part of a nodeset Caluclate the number of nodes in a nodeset Count number As for count but return a double valueN

Front Extract the first node in a nodeset N

Save ns Transfer a nodeset to transform allocatorN
memory space Save str Copy a strin into transform allocatorN
memory Documentl Implement a form of the XPath documentQN
function Document2 Implement a form of the XPath document()N
function Document3 Implement a form of the XPath documentQN
function Document4 Im lement a foam of the XPath document()N
function Sort Implement a custom nodeset sort functionN

Number Im lement a XSLT number format o erationN

Limit Limit backtrackin through this instructionN
to number times LimitN As limit but take limit ar ument fromN
the stack Match self Search for matchin nodes according Z' to XPath rules Match child Search for matchin nodes accordin I' to XPath rules Match attributeSearch for matchin nodes accordin Y
to XPath rules Match namespaceSearch for matchin nodes according Y
to XPath rules Match parent Search for matching nodes according Z' to XPath rules Match ancestorSearch for matching nodes accordin Y
to XPath rules Match ancestor-or-selfSearch for matchin nodes accordin Y
to XPath rules Match following-siblingSearch for matchin nodes according Y
to XPath rules Match recedinSearch for matchin nodes accordin Y
-siblin to XPath rules Match descendantSearch for matchin nodes according I' to XPath rules Match descendant-or-selfSearch for matchin nodes accordin Y
to XPath rules Match followinSearch for matchin nodes accordin Y
to XPath rules Match precedinSearch for matchin nodes accordin I' Set root to XPath rules N
Set the node considered the current document root node Set current Set the node considered the current N
node Swa current Swa the context and current nodes N

Extern Call an external su ort routine N

Push data tr Push a ointer value onto the stack N

Push data Push a se uence of data values onto N
the stack Push value Push a value onto the stack N

Co y Co y data fromlto stack locations N
Co y Co data from/to stack and lobal stackN
PushNP locations N
Push value on NP onto stack Po NP Po value of NP from stack N

PushHP Push Value of HP onto stack N

Po HP Po Value of HP from stack N

PushRP Push Value of RP onto stack N

PushLP Push value of LP onto stack N

Jump Unconditional Jum N
JumpE Jum on a uality N
JumpNeq Jum on ine uality N
Not Reverse a Boolean value N

OutCo yNode Pass a node to the ou ut handler N
OutStartElementCall start element routine on ou ut N
handler OutEndElement Call end element ou ut handler N

OutSirin Call ou ut handler with a string N

OutCopyTree Pass a tree to the ou ut handler N
OutPI Call PI routine on output handler N

OutAttribute Call Attribute routine on ou ut handlerN
OutComment Call Comment routine on ou ut handlerN

PattemMatch Initiate attern matchin N

Call Call a block by location I' LocalRef Resolve the data in a local variable N

GlobalRef Resolve the data in a global variableN

String Node Convert node to strip N
Strip Boolean Convert Boolean to strip N

Strip Number Convert number to string N

String Any Convert ANY to strip N
Number BooleanConvert Boolean to number N

Number Strip Convert strip to number N

Number Any Convert ANY to number N
Boolean NumberConvert number to Boolean N

Boolean SMng Convert strip to Boolean N
Boolean Any Convert ANY to Boolean N

Nodeset Any Convert ANY to nodeset i Example Transformation [0088] The following section contains a trace of an example transformation of a sample XML input document by a stylesheet performed with the Abstract Machine 300 (Fig. 2). The stylesheet, XML input document and output are shown first followed by an Abstract Machine instruction listing and a trace of the abstract machine state after each instruction.
The stylesheet is as follows.
<xsl:stylesheet versson="1.0"'xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<xsl:apply-templates select="name"/>
</xsl:template> ' <xsl:template match="name">
<greeting>
<xsl:value-of select="firstname"/>
</greeting>
</xsl:template> ' </xsl:stylesheet>
The input document is as follows.
<xiame>
<firstname>xevin</firstname>
<surname>Joxies<jsurname>
</name> .
The expected output is as follows.
<?xml version="1.0"' encoding='!utf-f"?>,- , ..,-r,-o.~t-; nn5xavi nc /areetina>
The Abstract Machine instruction listing for the above example stylesheet is reproduced below. Note that it is annotated with comments starting with "//°' to the right of the AM instructions, as well as lines starting with "! " that provide the source stylesheet instruction that causes the set of AM instructions to be output immediately following the stylesheet source line.
!-. bootstrap E.
OOOOOf00 // Create a bootstrap block (used 0 - block-O Eor globals) , //; Set, output format mode , .mode 0 1,2 output _ //::Start pattern matahizzg 20 :. patterii_match .

'36 return fxle:/d:/Sarvega/extern/napa/bim/ex:xsli3 ' ~empl.ate Match=/.Name=
~.

40. block':2,003D9E78 a b~:ock, reserving 2x32bit on-stack ;
// Create tile:/d:/Sarvega/extern/napajbin%ex.xsl:4:;

! -xsl: apply-templates' ' , 52 try 180 // Try the next Code,: on.backtracJc goto 180 '= param block lf~;~nz~. a parameter block da,ta 1 (0 ,0 0- 0 .
. ) -4 puskr.

, // Reset the nodelist at st'aek+0' , reset.0 , f-% Try the next code', on backtrack-goto $4 ~ try 156 1~6 '' 92 match child 2:':name//.,Find child.elemen~ called 'name ' 108' pattern match~orrcolleat:o /f'.Pattern match 124 .match child 65535::, 140, pattern_match ' 156 replay 0 164 pattexri match-180 return // A11 done;

file:/d:/Sarvega/extern/napa/bin/ex.xsl:7 Template Match=name Name= /f Create a new block & reserve 2x32, 003D8C30 bit values k'2 bl , oa i84 file:/d:/Sarvega/extexn/napa/biz~/ex:xsl:g 196 output xs~:~,start~,element:greeting // Output a start element file:/d:/Sarvega/extern/napa/bin/ex.xsl:9 ! xsl:value-of 244 reset 0 // Reset nodeset at stack+0 252 try 292 // Try the next code, on backtrack goto 292 260 match ohild 2::firstname// Find child element called '.firstname' 276 limit 1 // ~imzt backtracking to first xesult only 284 collect 0 // Store NP in nodelist at 0 and backtrack 292 front 0 // Set N~, to first node in sequence node // Convert NP to a string representation 300 string T // Output a string stririg 304 output ~ // Terminate an element 312 output_xs1_",end element 360' return // Bac~ktxack ~1 Below is a trace of the Abstract Machine State 900 (Fig. 4) reported between each Abstract Machine instruction. The fields are, ~ IP - Instruction pointer (offset is difference from start of listing) ~ BP - Backtrack pointer ~ SP - Code stack pointer ~ HP - Heap stack pointer Both the contents of the Code Stack 800 and Heap Stack 1000 (Fig. 4) are shown with values growing left to right and top to bottom. The memory dumps shown in the traces assume execution on a little-endian architecture.
********~.*******~******~*****************~*'***********.~*********************
***
LP;~-003A8050(of~set 0)<HP:,()35B0004 SP;: 03580004 HP: OODAOOQ-0 ' i Next Instruction: block O,OOb00000 Code Stack:
Lerigth=0 0 ., 0 '.p Q 0 0 0 .'0 0 0 .. 0 0 0 Q 0 . 0 "' . . . . . .
Heap'Staak~. '.
Length=0 0 0 . 0, 0 '. 0 ~ 0,- 0 , 0 0 0 0 0 : 0 0 0 . . . .
*************.********,*****************************~************.*************

IP: 903D895C(af~set l2) BP: .03580014 SP: C~3'SP0014 HP: OODAOd00 Next ~Instruction: output_made-4 Code Stack:
Length=1.0 1 0 'o ort o 4o as o 4 o sb s so so sd o . ..c~... L.P.;=.
0 0 0 0' . o o; ~, 0 0 0 . , o 0 0 0 0 ..'o . . . . . . . . . .
Heap' Stark:
Lexxgth-0 'o o a o 0 0 0 0 o a a o 0 0 .o o ....,... . .
******.~******~****************~*******:~********~**********************~******
*
IP: 003D8064taftset 20) BP: 03580014 SP: 03580014 HP: OODA0000 Next Instruction;' pattern match.
Code Stack: , Length=10 1 0 0 0 0 40 cd 0 4 0 5b 3 50 80 3d 0 .,...Q....f.P.=.
0 0 0 0 0' 0 0 0 0 0 0 0 0 0 0 0 ... ... , ....
Heap Stack:

bength=0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ..,......., .
*********************************************************~****,****************

TP: pp3D8078(offset 40) BP: 035B003C SP~. 035B003C HP: OODAp000 Next Tnstruetion: block 2,pp3D9DC8 Code Stack:
Length=38 1, 0 0 0 0 4.0 ed 0 4 0 5b 3 5p 80 3d' 0.:....~....L,.P.;.
0 0 0 0. . (7' 40 ed 0 4 '0 5b 3 0 p da ~,.,0 , ,.~...;, j.....
0 0, p 0 1 0 0 0 1 0 0 ,p.. p ~40 cd Q'- .... ,.. ..~..,."
14 0 Sb 3 64 80 3d 0 0 0 4 0 0 0 0.. 0 ,.[.cl._....<....
Heap Stack:
uength,0 , 0 0 0: p 'p ~ 0 0 0 0 .0 0, 0 '.p 0 0:, .. ..
*********************~t*********'*********,*******~************************:r.*
**~,*
IP~. 003D8084(of~set 52) BPr p358Op54 SP: 03SB0054 ' HP: OfDA.0f00 Next'Instruction:" try b4.
Code Staak.~
hength=50 1 0 .0 0 p 40 Gd ;'4 4 0 5b- 3 50 SQ: 3d ~ 0 ..,Q..,: j.P.=~ ', 0 0 0 p 0 40 ad 4 4 .,0 5b. 3 0 ,0 da:;, 0 :....Q....[......
0 0 0:;. o ~ .o p p 1 0 o p,:. o .4o aa: p .. ..:c~. .
x4 0'.5b a s4 so 3a. o o ." p o'- o .p 'o 0 0 . . ~:_a. . . .
1' 0 '0 '0 0 40 cd 0 3c 0 5b , 3 78 80' 3d 0 . ..-.C~..<. j.x;=.
p . p 0 0 0' 0 : p p . Q 0 p . 0 0.. 0 0 p . . . , . . . .
Heap:~tadk:
Dength=0 0 0 0 0' 0 0 0 0 0 0 0 ,0 0 0 0 . , ,.,...
***********:*****~**************:e~***********,r***~e**~e**~***,r***********;e*
******
IP:.~03D808C offset,60) BP: 035Bp068 ., SP: 03580068. HP: pODAOOOO
Next Instruction: param block Code Stack:
Length=64 1 0 0 0 0 40 cd 0 4 0 5b' 3 50 80 3d 0 ...,..~:..,j.P.=.
Q 0 0 0 40 od 0 4 0.5b 3 . 0 0 da 0 ....,C~....j.'..,.
0 0 0 0 ~. 0 0 o z o 0 0 0 4o cd o .....
14 0 5b 3 64 80 3d 0 0 0 0 0 0 0 0 0 ..[.d.=......:..
1 0 0 0 0 40 ad 0 3c 0 5b 3 78 80 3d 0 , .Ø:<.[.x.=.

1 0 0 0 Z 0 0 0 0 40 cd 0 54 0 5b 3 . . ~.,~C~-:T, L~
84 80 3d 0 0 0 0 0 0 ,0 0 0 0 0 0 0 .. ... ......,.
Heap Stack:
Length=0 0 0 0 0 0 0 0 0 0 0 0 0 0 .0 . . . . ', . . . . . . . ..
*********************************************************************~****~***
IP: 003D8090(o~tset 64a BP: 035B007C SP: 08SB007C HP: OODA0000':
Next Instruction: °;pusli data l (D~ D 0 0 , ,?;
Code Stack:, Length=78 .
1 0 -0 0 0 40 Cd-'0 4 0 5b 3 50 80 3d 0:: .:C~;-...j.P.=.
0.0000'40ad04:05b30;0da0.....~a....j.,..,.
0 0 0° o ~. o ;, o., o i ;o o , ° o o ~o' cd o . . .'. ~. , , 14-'' 0 5b 3,-r64 D0 3d 0 0,~ 0 0 0, 0 0 0 =0-.. j.d.=...~....-..
' 9' . 0 0 40 cd-r 0 3c 0 5b ~ 3 78 80 3d 0 . . . . .t~: .4. j=.x.=. a I j0 p ° 0 '1 0 0 =° 0 , -0 4a cd -'°'0 54 9 5b '3 .C~; .T.,j. .
84 80 -3d -,,0 0 4 t3 0 = 1 ,~.'0 0" 0 '0 40 cd '°0' . . . .Cg?. ~' 68 0 5b 3 8e 8D 3d 0 0 - 0 '0 0 0 0' 0- 0 h. L..:a. . _ "
Heap Staak:
Length=b: ' °,, '-,0 0 0 0- 0 '0 0 0 0 0 0 , 0 0 0 ., ******~*******v************~*************************+************~****~***~+*
IP: 003I7809C(of~aet 76L 82: 035B007C SP::03580080 HP; OOA~.0000 Next Instruction: reset 0 Code Stack:
LETlg~l7.a'JC ~ ~...; ,. .. ' '. ~ - ~ ..° ; - ., " s . ::-.
0 0: p '0 AQ cd 0 4; 0 5b 3 50 80 3d o ..,.~Q,...j.P.=:.
0, 0;'. 0 0 40 cd 0 4 ''0. 5b 3 p p da 0: .. ..c~:... [;..., 0 0 0 o i o 0 0 2 0 .o o , 0 46 'ca'' o . . . . . . .c~.:-:: °
T4 0 Sb. 3 64 80 3d 0 0 0 0 0. 0 ~ 0 0 ... L~d~=..,......' 1 0 0 -0 0 40 cd 0' 3a 0 5b 3 78 80 3d 0 .....Q..<:,j.x.=.,:
0 0 0 0 40 cd 0 54,;0 5b 3 .. ....~..T.L-'.
84'80 3d 0 0 0 0 0 x 0 0 0 0 40 cd 0 .. ..... .,~,;
68 0 5b 3 8e 80 3d 0 0 0 0 0 0 0 Q, 0 h.L..._.~..,.,., Heap Stack:
Length=0' 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ................
******************************************************************************, IP: 003D80A4Io~~set 84) BP: 03SBOp7C Sp: 035BOp80 HP: pODA0000 Next Instruction: try 9c Code Stack:
Length=7o 1 0 0 0 0 40 ed 0 4 0,5b '3 50 80 3d 0 ..,'..0,...C:P,=.
0 p 0 .,0 0 40 cd p 4 0 5b 3 0 0 da 0 ...",0..,.C...,.
0 0 0 0 1 0 '0 ,0 ~, 0 0 0 ,0 40 Cd 0 .....,..,.:.Ø.
14 0 5b' 3 64 80 3d 0 p p' o p 0' 0 0 0 ,.[.d.=........,:.
,. 1 0 p o 0 40 cd 0 3c 0 Sb 3'78 80 3d '9 . ,..~..<.C~x.=.
Zv: O 0 0 '.i 0 p p 0 40,, cd -0 54; 0'-5b 3.'...:......Ct..T. C. ':
84 80 3d 0 p .0, p,, p' 1 ... 0;' 0 . p 0 40 ed , 0". . ... ..~..
6,8 b 5TH 3'8c:80 3d' 0 0~ 0- 0 .p 0, p;::p .0 h.C...= .,.....
Heap StdG)C:
Length-.0 o ;o b o: o ,a'.o.: p o o' p o 0 0 0 0'.:... ..
''.,**************'it*****'k********'k,*********~k$'**~***at****'k'*~******::4.
'******.****,~,F**~k***k Ip: Op3D80AC{offset 92} BP: p3SB0094 Sp:,035B(?094 HP: OpDA0p00 Next Tnstruetiori: match child 2:: name Code Stack:
Length=90 1''0 :-0 p 0 40 cd 0 4 :0 5b 3 60 8p 3d' 0 .,...Q;:.,L:P.=.
0 0 0 p:4'0 ed 0 4~, 0,;5b ,3 , p 0 da,' p . ..Q..,:C.,....
p 0 0 0 1 0 0 0 1 '0 0 0 0 40' cd ,,0 . ., ..Q..
14 0 5b 3 64 80 3d .0 0 0 0' - 0 . 0 -0 0- 0' C.tl:=.~: ... : . .:
'.1 ' o Q 0 0 40 ad -P 3c ~ p 5b ~ 78 BD:.:3d -. p ., ..~a..<.:'[.x.=, .o o ~ 0 1 o f' p °''o ~:o as o s4J o ~b 3 , . . ~ . .~:.-~. I.
a4 ao '3a o 0 0 0' o ' ~. , : o 0 0 0.~ 40 .ca ~ o . . . . . . . a: .
'6s ..0 5b 3 $~ so 3'd =o~ o o 0 0 ~, o,~ o o h. C , :'_..: : .. ~: .
1 0 -0 p 0 40 cd ',p 7c : 0 5b 3 a4 803d 0 . . . ,~. . ~ := C. . .°=.
0 0 ' 0 0 0 0 '0 0 : 0 0 0 p . 0 0'' 0' 0 . . . . , ' , .
Heap Stack: , Length=0 0 0 0 0 0 0 0 0 p p n 0 0 p 0 ,..,,...,.......
***************.e**********************************,r*************************, r*-Ipe 003D80BC{offset 108} BP: 03SBODA4 SP: 035BOOA4 HP: OODA0000 Next Instruction: pattern match or col.l.ect :0 Code Stack:
Length=a0 p 0 0 0 40 cd p 4 0 5b 3 SO 80 3d 0 .. ..C~...,C,P.=.

0 0 0 0 0 40 ed 0 4 0 5b 3 0 0 da 0 ...,:Q,..,~(:.~.-0 0 0 0 1 0 0 0 1 0 0 0 0 40 cd 0 ............Ø..
14 0 5b 3 64 $0 3d 0 0 0 0 0 0- 0 0 0 ..[.d.=.........
1 0 p p .0 4p cd p 3c 0 5b. 3 78 80 3d 0 . ..'.~..< [,x.=.
1 .p p p 1 .p p p 0 40 Cd 0 54 0 5b 3 . ......Q..T.[.
84 80 3d 0 0 0 0 0 1 0 0 0 0 40 cd 0 .. .......~~.t~.~
68 0 5b 3 Sc 80 3c1 0 0 0 0 0' 1 0 0 0 h.[.::_.:....... ' 0 o p o 4o ad; o as o sb .a a4 $o ad o , ,,.c~..~.C.. , 1 0 0 0 0 40 ed- 0:.94 0 5b: 3 ae $~ 3d 0 . ..,,0..;'.[,,.._.
n 'p o' o ' o ' p ;o o p o p p p o 0 0 ;. . , Heap Staak:
Dengtb_~
o . o ° o.: o 0 o p o o -o-: o p :.:o ' .
*~*******.~*******-**********~,~************~**~~******~************:*******~*****
TP.~ 003D$108(offset 184) Bp': 035B00CC Sp::035BOOCC-: Hp: LtODA0004 Next Ti~.st~ta.ction: block 2~003D8AE8 '- > .
Code Stacks Length=e8 "
0 p, p ,p 40 Cd p..4 0 5b 3 50 $0 3d 0 ....'.Q....['p,-.
0°~ 0 0 0 ~' 40 ad ' 0 4 0 5b '-3 0 O da ;,0 . .:c~....;(.. ..
'0 0, 0 0 1 0 0 0 ~, ' 0 0 0' 0 40 Gd 0-... ' , ~ ~.C~..
14 0'Sb 3 64 80 3d 0 ~0 °0 da': 0 4 0 da 0 ,.. [;d.= : , i 0 0 0. 0 40 cd;:..0 3c 0 5b. 3 '78 $0 3d 0 :....p.,c-.[.x.=. "
1: 0 0 p 2 0 0' 0: ~ 40 ed 0 54 0 5b 3 , ,. ..~,:T, [.
84 80 3d p p 0 p 0 L 0 0 0 Oy40 cd 0 .. , , ,.G.
s'a a sb a $c so ad a oT o , o '0 1, 6 0 o h C. :~.._ . , .
1 0 D 0 0 40 cd 0 ,~c , 0 5b 3 a4 80: 3d 0 . . . . Ø.'. ~ . [,.. . _., 1 p p , p 4 40 cd '0 94 0 5b ., 3 ~c 80 3d '-0 . . . ..c~. . . [.. ~=.
7a 0 5b 3 0 9:~0 ci3. 0 3c':'p Sb 3 4 0 da 0 ~ . [..G~ .<. [~.....,, 0 0 p p 1 p p., 0 ~ ''0 0' 0' 5c 40 Cd ,0 .. . ..:\p, . ' a4 0 5b 3 he $0 3d O 0 :' 0 0' 0~ D 0 0 0 . . [.. . . . . , . .
Heap Stack:
Length=4 p 0 0 p a, ~ 0 p 0 .0 0, 0 0 .0 0 ;...,. "..... , *************************************************************************:~***~

IP: 003D8114(offset 196) BP: 035B:OOE4 SP: 035BOOE4 HP: OODA0004 Next Instruction: output xsl start element :greeting Cods Stack:

Length=e0 1 0 0 0 0 40 Cd 0 4 0 5b 3 50 80 3d 0 ...::Q~...[.P~=
0 0 0 0 0 40 ad 0 4 0 5b 3 0 0 da 0 .....~....[~~~~~
0 0 0 0 1 0 0 0 1 0 0 0 0 40 cd 0 .......~..~~.~~~
14 0 5b 3 64 80 3d 0 O O da 0 4 O da, 0 :.[.d.=,.~..
1 0 0 0 0 40 Cd 0 3c' 0 5b 3 78 80 3d 0 .....Q..<.[~x~=
1 0 0 0 1 0 0 0 0 40 cd 0 54 '0 5b 3 ........~C~.~T.[.
84 80 3d p p 0 0 0 x . 0 0 , o '0 40 Cd 0 -. . , . ,C~, .
~ 68 , 0 8b 3 '8c 80 3d 0 0 ~ Q; 0 1 ~~ 0 ~ h.~[.':._. ~ .. ..
1. 0 0 0 0 40 ad 0 7c :0 5b 3 a4 '80 3d '0 .....Q,.~,[,.._, 1 '0 '0 0 0 4~ Gd 0 94' 0 5b- 3.;~.c 80 3d Q......W ...[...=.
7c 0 5b 3 0 40 ad 0 3c 0 Sb' 3 '4 0:da. 0 ~.I..C~. <:[.-.,.
p 0 0 1 0 0 p 5c 4'0 cd 0, ~ ~ ~\Q~
a4 0 5b -, 3 be 80 3d 9 . 0 ' 0 'p p' p ~ ,;b 0 .. [~ :._.
1 0, 0, 0 5c 40 ad :> 0 cC '0 5b 3~ 8 81 3d 0 . .\~. . ~ ~ [~'~
p :; p : p ,.p .o p p a p o p,;, o ~.o 0 0' o .
Heap Staek:
Leiigth;4 p , O 0 0 0 0 0 ~ ' 0 0 0 **************;~************,~'*****,~*************;~**x;,r*~***************:**
****~e** '.
TP:': 003D8144{offset Z44), B$:;'035B00~4 . sP,: 035Bp0E4 HP: OODA600,4,' Next Tnstruction:a reset. 0 Code Btaak:
T~ength=e0 1 0 '0 0 0~ 40 cd .0 4 0 5b 3 50 80 3d 0 , "~,...F[.~'._.
0 -.~ 0 4.0 cd 0 4 0 5b': 3 D 0 da 0 . "::Q.,..[.~...
r.
0 0 ~ 0 0 1 0 0 0 1 0 0' 0 0 .40 Cd Q ~ , . . :.Q.. ' ~,4 0 5b 3 64 80 3dv,p 0 0 da ,0 4 0 da p ~~[.d,='... ....
0 0 0 0'-4p ad ;p 30 0 5b 3 78 80 3d 0 ..~a..<,,~.x~=.
1, 0 0 0 1-' 0 -a0 ' 0 0 40 cd -0 54 0 5b 3 . . ..c~s.,.T. [.
84 80 3d O.v 0 0 0= 0~ 1 0 0~ 0 0 40 cd'. 0 " .... 4 .:-.Cv.,.
68 0 5b 3 So 8p.3d ,0 0 p 0 0 ~ 0 0 0 h.[.:-._.......,.
0 0 0 p 40 cd 0 7c 0 5b "3 a4 80 3d 4 , ..~,.~.[..._~ .
1 0 0 0 0 40 ad 0 94 0 5b' 3 ac 80 3d 0 ,..,.~...,,I~..=.
7c 0 5b 3 0 40 cd 0 3a 0 Sb 3 4 0 da 0'j.[..~..<.[.....
0 0 0 0 1 0 0 0 1 0 0 0 5C 40 od 0 ... . , ...\~..
a4 0 5b 3 be 80 3d 0 0 0 0 0 0 0 0 0 ..[..._.........
1 0 0 0 50 40 cd 0 cc 0 Sb 3 8 81 3d 0 . .\c~~...[..._~

p' 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .., ..,...., ..
Heap Stack:
' Length=4 0 0 0 0 0 0 0 0 0 0 0 0 0 '0 0 0 ................
*********;r********************************************************************
' IP: 003D814C(offset 252) BP: 035BOOE4. SP: 03SBOOE4 HP: OODAOb04 Next Instruction: try 124 ' Code Stack;
Length=e0 1 0 0 0 0 40~ cd 0 ''4 0 Sb 3, 50 80:3d 0 . ..c~...,;I.P.=. ' 0: 0 0 0 p 4p C~:, p 4 4 Sb 3 p . p as 0 . ..0::..~.:..:
0 0; ~', p ~,; , p . Q 1 0- 0 0 .:0 40 ad; 0 . .. . . <C~..
14 :.0 5b 3 64. 80 3d 0 0 - 0 da ~ '0 ~k 0 da '0., . . I .d.=.'. . . . . . .
0 : 0 '0 b hb cd 0 3c 0 Sb.~3 '7f 80 3d ;~ ~ ..~..<.''j.x p 1 .0 0 0 0.40 cd 0 54. 0''5b- 3 .. ....C~.:T.I.
s4 so ~a a :o .o o d 1~~ o b ci o.4o..ad o . ,:.c~..
6s o sb a s~ so 3a o . o o' o , a 1 0 0. p. h. I:; , _ =.
:~ y o 0 6 0~ 4o as o ~c Q Sri- a:a4 so 3d 0 . .,~..~..,I.,:_, 1 0 0 0 040 ad' 0 94 b Sb 3 ac &0 3d 0 ., .-.~....I,..=.
7C 0 Sb 3 0 40 cd 0 3c p 5b '3 4- O da 0 ~.I.:~..<.I~'~..::
p p p ,0 Z 0 D v' 0 ,1 0 0 0 5c -40 cd 0 . . .\Q. .
ah 0 5b 3 be 80 3d 0 0 '0 0- 0 0 . -0 0 -0 . . I ~ . :, , . . . . .
1 0 0 0 5c 40 ad. 0 cc 0 5b 3 8 81 3d 0 . .\C~.,.I..:_, 0 0 '0 0 p p ,p 0 0. 0 0, 0 0 0 0 0 ..
heap stack: _ Length=4 0 . 0 0 0, Q:= 0 , 0. 0 '0 0 0 0 p 0 0 0 , ,.
*************v*********ai******:~*~****x***~***~*********,~~r****'********a****
***a IP: 003D8154(offset X60) , BP: 035BOOF8 SP: 035BOOF8 : HP: ObDA0004 Next Instruction: match ahild.2~.:tirstname Code Stack;
Length=f4 1 0 0 0 0 40 cd p 4 0 Sb 3 50 80 3d 0 ....,»t~,.;.I.P.r, 0 0 0 0 0 40 ad 0 4 0 5b 3 0 0 da 0 . . . . .C~, . . : I: . .: .
0 0 0 0 1 0 0. 0 1 0 0 0 0 40 cd 0 :....... ' ..Q..
14 0 5b 3 64 80 3d 0 4 0 da 0 4 0 da 0 ..I.d.=.........
1 0 0 0 0 40 cd 0 3c 0 Sb 3 78 80 3d 0 .....C~..<.I.x.=
1 0 0 0 1 0 0 0 0 40 Cd 0 54 0 Sb 3 . ..~..T~I~

84 80 3d 0 0 0 0 0 1 0 0 0 0 40 cd 0 . . . . . . ,c~. .
68 0 5b 3 8c 80 3d 0 0 0 0 0 1 0 0 0 h.L...=.." .~.,.
1 0 0 0 0 40 cd 0 7c 0 Sb 3 a4 80 3d 0 .....t~..I~[~~~_~
1 0 0 0 0 40 Gd 0 94 0 5b 3 aC 80 3d 0 .....c~....L..~=.
7c 0 5b 3 0 40 cd 0 3c '0 5b 3 4 O da 0 I.L..~..<.[.;...
0 1. p 0. 0 1 0 0 0 5c 40 cd' 0 .........,...\C~..
a4 0 5b. 3 be 80 3d 0 0 0 0 0 0 0 0 0 ..L...=.. .....~
1 p 0° 0 5c ~0 Gd O ec 0 5b 3 8 81 3d 0 ...:\Q;...L...=.
p ~ p p 0 5e 40 ed 0. e4 p 5b 3 . .~.\C~:.,.L. ,.
4c 81 3<1 0 0 . p :.p p , p , 0 0 ' 0 .b .0 :.,0 ,0 L.-~ , ~'. ~ ... ,~; ~ .
::
Heap Stack: -Length=4 p p 0 0 O D 0 , 0 0 ;,:~ p p p 0 0 0 .. . .
..
******.***~************::t**.***********;r**x~r*****.******~***,~:****,r~***~**
**,t**~e:,t**,**
IP: 003~D.8164(o~~Set 2'76) . ,BP~:035B0108 , SI?: 035B0108 ;- HP: OOI7A0004 Next InStrtlCtionr;, ' limzt l Code Staok:.
vength=i04 1 0 0 0j 0.40 cd ~0 ~ 0 Sb 3 50 80 3d 0'~~ ;.Q,~~,[.P =.
0 0 0 0 '40 cd 0 4 .0 5b:: 3 0 0 d2~ 0 .. ..~~.~.,[.~~..
0 0 ~ 0 0 0 I 0 0 0 0'40 cd 0 . .. . ~ ~~..
14.' 0 5b $ ~4 80 3d : 0 0 p da 0 4y p da 0" ~L~d.-..:,..
1. 0 4 p . 0 40 cd ''0 3c ~- Sb- 3 48 '$0 3d. 0~ . ..~a:.a.~.x.=.
1 0 0 0 , 1 0 0 . 0 0 40 ad 0 54 0 Sb 3 . . .:,r~..T. L.
84 80 3c1 0, ~ '. 0 ' Q ' 0 1 r0 :0 ~ 'p 40 cd 0 . . ~.. : , 68 p Sb° 3'' 8e 80 3d -; 0 0 .0 . 0 > 0 t--1 0 ,;,0 0 h. L- , .
1 t-'0 0 0'~ 0 40 cd ,.~0 7c 0 Sb- 3-, a4 80' 3d 4 ~ , . ~~~ . ~ .~[. ' 1 0 a0 0 0 40 cd 0'94 U 5b $ ac 80 3d -e0 . ~;.Q. ..-. L
70 0 "'Sb 3 0 40 cd 0 3c 0 5b 3 :: 4 0 da 0 { . L.;Q. .<. L. . . ..
p ;.1. 0= 0 0 5c 40 Gd 0 . .. .. ~.\~~.:
a4 -0',Sb, ,.3 be ~80 3d. ~ 0 p p 0 p' . Q ~ . ~,C..__ ..... , 1. 0 0 0 5c 40 cd 0 co 0 5b 3 8 81 3d 0 ....\c~ . .L...=.
1 0. 0 A ~. 0 0 0 5c 40 cd 0 e4 0 Sb 3 ......,.\0.....L,.
4e 81 3d, p ~ p ,a d Sc 4p ed 0 f8 0 5b 8 L.=..-.,.\C~..,.L.
54 81 3d 0 0 0 0 0 0 0 0 p p 0 ~ 0.'t.=.,~,:..~.~~.~
Heap Stack:
Length=4 0 0 0 0 '0 0 0 0 0 0 0 0 0 0 0 0 ..... .........

******************************************************************************
IP; 003D816C(offset 28'4) BP: 035B0118 SP: 035B0118 HP: OODA0004 Next Instruction: collect 0 Code Stank:
Length=114 1 0 0 ,0 0 40 cd 0 4 0 5b 3 50 80, 3d 0 :" ..C~..:.C.P,~.
0 ~ 0 0 0 40 ed 0 4 0 5b 3 0 ' 0 da 0 . . . "O. . . . C: . , . .
0 0 0 p,.:1 p, 0 0 1 0 0 a 0 40 cd 0'. ........,c~..
14. 0 Sb 3 64 8a 3d 0, a p da 0 4 0 da 0 ..L=d.=.........
1 q' 0 0 0 40 cd 0 3c a 5b '3 78 8a'3d p , ,.~.:<.[.x.=.:
1 . 0 0 0;' 1 p 0 0 0 40, od 0 54 0 °5b 3..... ..c~..T. ~.
$4 80 3d 0' :a 0 0 0 1 0 0,. 0 p :40 Cd 0 , .. ..5~: , 68 0 5b, 3 8o y80 3d ; a ~ o , p a y a 0 Q h. [. -.._. ...-.. ...
rv 1 0 0 0 ',0 .40 Cd, 0 7e.,: 0 5b ,3 a4 ?80 8d- . a . . ,c~ ;..~'. C. , ._.
o ~o cd..a ~4 a sb ,~ ac 8:0 3a a . :Q....t~...=.
7a 0,5b ..3 0 4a cd 4 3c 0 5b 3 4 0 da '0 ~.[..Q .<.[;_....
'oy a :, o o . i o 'o - o . ~ o o a sc 4a as o . . : . . . : . \~. .-a4 0 5b :.3 be 80 3d 0 0 0 :0 0 0 0 0 0 .,C.._.....:..<
1 0. 0 0: 5c 40 cd 0 cc '0 5b 3; 8 81 3d 0.. "\C.... [:'.._.
1'::. 0 0 0 1', a 0 : 0 5c 4p ccl 0 e4 p 5b 3 . .. ,\t~. . . . [;
4c 81~3d 0 1 a 0 0 50 4Q cd :0 f8 .Q 5b 3, Tr._,~....,\C~,~...., [. '., 54=al 3d'. 0. i o a o;-6:7 41 ad ~:: $ 1 ~b 3 ~:=,»...gA.:..[.
64 81 '3d 0 ..d 0 ';gyp 0 0 0 0 -0 -.0 0, 0 Q d.'-=. . :., . . . , .'. .
Heap Stack:
Length=~.,. .
a .;a 0 a 0 0; 0a- .a a, a 0 a 0 0 a . ...... ....
********~e:e******,***********:;~***********~***********~~***********:******~**
****~ , TP: aa3D8164(a~fset 276) BP: 03SB0118. SP: 43SB0118 HP: OaDA4008 Nat Tnstruetion: limit 1 ..
Code Stack:
Length=114 1 0 0 0 0 40 cd. 0 4 0 $b 3 50 80 3d .a ., .,Q..,.[.P.=, 0 0 0 0 -0 ..40 cd 0 4 a Sb 3 0 0 da ..0 .....c~...: [....,..
0 0 0 0 1 '0 0 0 1 0 0 a 0 40 cd a . .. .....Q..
14 0 5b 3,64 80 3d a 0 0 da 0 4 0 da 0 ...[.d.=..... .
1 0 0 0 f 40 ad 0 30 0 5b 3 78 80 3d 0 .....Q..<'.[.x'._, 1 0 0 0 7, 0 0 0 0 40 cd 0 54 0 5b 3 . . . ... , : .t~. .~. j, ,, 84 8a 3d 0 a 0 Q 0 1 0 0 0 0 40 cd 0 . .......,..Q.;
68 0 5b 3 8c 80'34 a 0 0 a 0 1 0 0 0 h, [...;"."....

1 0 0 0 0 40 0 ?c 3 a4 80 0 ...:.C~,.~,[..,=.
ed 0 5b 3d 1 0 0 0 0 40 0 94 3 ac 80 0 . ...Q...:[_ cd 0 5b 3d 7c 0 5b 3 0 0 3c 3 4 0 0 ~.[..~..<.[...
40 cd 0 5b da 0 0 0 0 1 0 '0 1 0 5c 40 0 .......... .\~
0 0 0 cd a4 0 5b 3 be 80 3d 0 4 0 da 0 8 0 da 0 ..[..._......:,..' 1 0 0 0 5c 40 cd 0 cc 0 5b 3 8 81 3d 0 ....\~...:[.,.=,.
1 0 0 0 1° 0 0 0 5c 40 cd 0 e4 0 5b 3 . . . . . . . . \c~. ; . . [.
4c 81 3d 0 1 p 0, D SC 40 cd 0 ~8 0'Sb 3 L.._...;.\~..'..[, 54 81.3d 0 1 : 0 0 0 6? 41 cd 0 8 1 Sb .3 T.=..:.,,vgA....,[.
64-'81 3d 0' 0 0 0 O 0 0 0 0 0 ''Q., 0 0 d:=........,....
Heap Stack:
length=8 0000'.6?4lCd0S7'..,0000.'0~00-...gA..
*****'****:+~******~e***x****~*******~r**~'*******~:*************,~****;r~*****
:e******
IP: 003D814C(o~fset 2521 , BP: 035BOQF'8 , SP: 036B04E8 FTP: OODAOOD8;
Next Instxuction: try 124 ~ .
Code Stack:
'LengthT~4 1 0 0 0 D 40 od .:0 4 0 5b 3 50 80 3d '0 :....U:. " [,p,_.
0 ' 0 0 0 0 40 cd .-0 4 0 5b ~.: 0 0 d~: 0 , .:.c~,... [;.:., 0 0 0, 0 1 0 0 0 ~, 0 0 0 0 40 cd 0 .... >:. ...C~.. ,.
1.4 0 5b', 3 64 ~9 3d 9 :0 Q da 0 4 , 0 da 0 .,j:d.=.:...
1 0 A 0 0 40 ad 0 3c 0 Sb 3.?8 80 3d .0 .. ::Cw..<.[~.x.=.
1 0 ~ 0 1 '0 ~' , ~ 0 40 cd 0 54~ ~ .,0 5b 3, , . ,p,.T. I.
84 8p 3d 0 0 0 0 0 Z 0 0 0 0 40~cd 0 . ..--C~-68: v0 5b 3 8c 80' 3d 0 0 - Q: 0 0 1 0 0 0 h [ -. . _'. . . . . : . : .
1 0 0 0 0 4d cd d 7a 0 Sb 3 a4 80rd 0 . ..~,.~~[..~_.
1 0 ~0 ,"0 Q 40 Cd 0:94 0 5b 3 ac.80 3d 0 .....c~...':[..._.
?c 0 5b 3. 0 40 cd..0 3c 0 5b 3 4 "0 da 0 ,:~..[..Q..<.[......
0 0 0.' 0 1 ; '0 0 '',0 . 1 , 0 0 0 5C 40 Cd, 0 . ..\C~..

a4 ''0 5b 3 be 80 3d 0 4 0:'da 0 8 0 da 0 ..[.....-.,:.:....
1 0 0 o so ~o ca o ~c o 5b ~ s si:3d o : ,.\~..,.[,,._,;
1 . " 1,=0 0 0 5a 40 cd 0 e4 0 5b 3 ,. ..:\~...,[, 4c 81 3d 0 0 0 0 0 0 0 0 0 Q 0: 0 0 L.,.......,.....
Heap Staok:
Length=8 0 0 0 0 6? 41 cd 0 0 0 0 0 0 0 0 0 ....gA..........
******************************************************************************

IP: 003D8174(offset 292) BP: 035BOOE4 SP: 035HOOE4 HP: 00DA0008 Next Instruction: front 0 Code Stack:
Length=e0 1 0 0 0 0 40 Cd 0 4 0 5b 3 50 80 3d 0 .....t~..,.I.P.=, 0 0 0 0 0 40 cd. 0 4 0 5b '3 0 0 da 0 .....Q...;[..,,.
0 0 0 0 1 0 0 0 1 0 a o 0 40 ~d o ....... ..~..
14 0 5b .3 64 80 3d 0 0 0 da 0 4 ,0 da 0 ..I.d.=....:.:..
1 0 0 0 0 40 cd 0 3a 0 Sb 3 78 80 3d A .....~..<.I.x.=.
1 0 0..0 1- 0 0 -'0 0 40 cd 0 54 0 5b 3 .. , ....~.:T.I. -84 80 3d 0 0 0 0 0 1\ 0 0 0 0 40 ed.. 0 .. . , ..t~..
68 0 5b 3 8c 80 3d 0' 0 O -0 0 1 ~0 0 0'h.[..:=..,.:
7. 0 a 0 0 40 ad 0 '7c,.;. 0 5b : 3 a4 80 3d 0 , . ..C" ~',. [..._.
,0 0 ~' p 40 cd 0. g4 0 .5b 3,:ac 80 3d 0 . ..:Q,..,[.,._...' 7e. 0 5b 3 0 40;ed- 0 3c 0 5b 3 4 0 da 0 ~.[.,~..<.('.....
0 0 0 '.0 1 0 ~ p 0 1 0,' :~ Q 0 5c 9 0 Cd 0 . . : . ~~. , ;.
a4 0 5b 3 be 80'3d 0 4 0 da 0 8 0.da 0 ..I~.: .., L 0 0 - 0 5c-.:40 ad 0 cG -p°5b 3 ~-8 81 3d- 0 .. ~\~....,[.. ...
0 0' 0 0- 0 0' 0 0 ;0 .0 0 0 0,;0 0 .0 ................
Tieap Stank:, Lengtkr8 , o ~ o o s~ 41 ca a o 0 0 0 0 0 0 -a' ....s~,:...,.....
***********************************~**************-*******~:*******************
IP: 003I7817C(offset 300), BP: .035HOOE4 - 8P:' 035BOOE8 HP; OOD~10008 Next Instruction:, strzag node,, r Code-Stack: -'Length=e4 1 0 0 0 0 40 od,','0 4 0 5b .3 50 80. 3~d 0: , ...t~..., j.P.=:.
0 0 0 0 0 40 ad° 0 4 0 5b 3 .0 0 da 0. ...:.~,,..[,...:,, 0 '0 0 0 l '0 0 0 1 0 0 0~. 0 40 cd 0 .,....,.,...,t~..
0: 5b 3 64 80 3d 0 0 0 da 0 4 .0 da 0 ..[.d.=.,....... .
1 0 ...0 0 0 40 cd 0 3c 0 5b 3 78 g0 3d 0 .....Q..<,[.x:_...
0 1 0 0 0 0 40 cd'~; 0 54 0 5b 3 ...... ..C~..T. [, 84 80 3d 0 0 0 0 0 1 0 0 0 0 40 Cd 0 .. ..... .:-Q..
68 0 5b 3 8c 80 3d 0 0 0 0 0, 1 0 0 0 n.[..._..:.......
1 0 0 0 0 40 cd 0 7e 0-5b 3 a4 80 3d 0 . ...Q..~.[.~~=~
1 0 0 0 0 40 ad 0 94 0 5b 3 ac 80 3d 0 .....~....[..._.
7c 0 5b 3 0 40 ed 0 3c 0 5b 3 4 0 da 0 ~.I..r~..<.[.....
0 0 0 0 1 0 0 0 1 0 0 0 5c 40 ed 0 . . .~C~~

a4 0 5b 3 be 80 3d 0 4. 0 da 0 8 0 da 0 ..[..._.........
1 0 0 0 Sc 40 cd 0 eC 0 Sb 3 8 81 3d 0 ....\~....[~.._.
6741 cd 0 0 0 0 ' 0 0 0 0 0 0' 0 0 0 gA: . . : . . . . . . . . . .
Heap Stack:
Length=8 0 0 0 0 67 41 cd 0 0 0 0 0 0 '0 0 0 ....gA.... " ....
***********************~******************************************************
18: 003D$1$0(offset,3Q4) BP: 03Sb00E4. 'SP:03SBOOE$, HPrs OODA000$
next 2nstruction: " output~string Code='Stack:
Le~zgtb.=e4 ; .
0 0 0 0.;40 Gd .y0 4 0 Sb 3 50 89 3d 0 . ..C~ , .,:['.P.;:~.
0 0 0 '.0 40 Cd ~ 0 4 '; p.Sb 3 0 v Q' da . 0 . . . ..Q . . :',[~ . . . .
0' 0 0 0:;1 Q 0' 0 1 0' 0 0 ..~ 40 ed..0 . ... .:Q:.
14 0:5b 3 64 80 3d' 0 0 0 da 0 4 0 da 0 ..[.d.=,..,,...':..,.
0 0 0 4o=cd o aa' n Sb 3 za $0 3a o ,.....~,.~.[.x.=.
~. o o.'- o o ~o ect o s4 ;-a 5b "~ .:. ..c~; ,x.:[.
$4 $o ~d 0 0 'o o ',o .1 0 , a 0 0 4a' ad o . .. . , , . . .~...:
68 Q Sb 3 8c' 80 3d0 0 0 ;0 0 1 0 ° 0 0 h. [. ;-. _, . . . , .
7.' 0 ,0 0 ~ 0 40 gd 0 7G :0 Sb 3 x.4.:80 3d .0 :' ...Q. . ~ ..j: .
0 v 0 0 0- 4D' Gd 0 94 ,: 0 Sb 3 ac $0 3d 0 . . . , .
7e 0 5b 3 0 Oft ad 0 3c,°. 0 6h 3 . 4 0 da ~ 0 ] . [. :c~: z~. (.. ..'.
0 0 o a: ~ o 0 0- 1 0 '''.o o Se 40 Gd o . . . ~c~~ .
a4 0 5b 3 bc-80 3d 0 '4 0 da p.,8 ,0'~a,:',0 ,.[... ....,,., Q 0:~ p 5c 40 cd :. 0 GG ,' '0.:5b 3 8 ~$J. 3d 0 . ..: \~. . . . [ . .
23 42 ed 0 0 0 0.- ;0- Q 0 ~0;. 0 =0 0 .0 0 #B.>, .. ..
Heap Stack:
Length=$ .- f 0.0,006741,cd00000000':''0..:gA.....=......
*******************************,~****,******************************,~*********
*
TP: 003D8188(offset 312j BP: 03SB00E4 SP: 035BOOE4 HP: OODA0008 Next Instruction; output_xel._end,-eJ.ement Code Stack:
Length=e0 1 0' 0 0 0 40 ad 0 4 D Sb 3 5b 80 3d 0 .....C~,...[.P.~.-0 0 0 0 0 40 ad 0 4 O Sb 3 0 0 da 0 .....Q....[.....
O 0 0 0 1 0 0 0 1 0 0 O 0 40 Cd 0 ....... ..Ø.
14 0 Sb 3 64 $0 3d 0 0 0 da 0 4 0 da 0 ..[.d.=.........

I 0 0' 0 0 40 cd 0 3c 0 5b 3 78 80 3d 0 ...;,.t~,.<.(.x.=.
1 0 0 0 1 0 0 0 0 40 cd 0 54 0 Sb 3 .........~..T.C.
84 80 3d 0 0 0 0 0 1 .0 0 0 0 40 ad 0 .. ..........c~..
68 0 5b 3 Sc 80 3d 0 0 0 0 0 1 0 0 0 h.(..._.........
1 0 0 0 0 40 cd 0 7c 0 5b 3 a4 80 3d 0 . ..:i~..~.(..._.
1 0 0 ,0 0 40 cd 0 94 0 5b 3 aG 80 3d 0 .. ~Ø...[..,-.
7c 0 5b 3 0 40 ad 0 3c 0 Sb' 3 4, p da p.Ir[",~..<.L...., p p 0 p' 1 p p 0 1 0 0 0 5e 40 ad 0 ., ......,~\c~,.
a4 ~ 5b 3 be 80 3d 0:' 4 0. da 0 80 da 0 ..~;..m..>.. ..
1 0 0 O,Sc X10 ad p GG 0'Sb 3 8 81 3d 0 . ,.\~:.,.[..._.
0 0' 0 0 ' 0 p p p , p p - p p p ' p p p . . . . . . . . .,.
Heap.Stack:
Length--8 ° ;, 0 0 0' 0 6T,,41 cao 0 0 -p o o b o o ....gA,......,..
********************************.~~**************.*******'******~**************
**
I'P: 003F38188(o~~set 360) BPn.,035B00E4 SP: 035SOO~~k HP': OODA0008 ,-Next Tnstruction: retvxn ~pde Stack:
Length=e0 1 0 '0 0.: 0 40 CC1 0 4 0 5b 3 50'80 3d.'0 ..,.Q..._:;C.P.=. . ' 0 0 0 0 0 40 cd: 0 4': 0 5b 3 0 0 da 0 ....;~C~....t:;:..
p ;p o i o o. 0 1 f o o- o ~ ~o ad ..'o . ......c~..- ~.
14 -:0 5b 3-64 80 3d 0.~0 0 da 0 r4 0-da 0 ..[.d -,. . , 1 0 0 0 0 40 ed 0'3c 0'Sb 3 78 80 3d 0 ,. ..~,.<..[,x,=:
0 -0 0 1. .0 0 Q 0 40 cd p S4 ..p Sb 3 .. . "C~..T.L~".
a4 so 3d o 0 0 ' -o 0 1. - o . o 0 0 ~o =cd q . ,-.. , . . . ~. . f ss o sb 3 sc:: $p ~d ti o o ' o o z- 0 0 o h~ C': , .
1 0 0 0 0 40 ed 0 '7c 0 Sb 3 x.4.80 3d 0 ,..,.c~..~.(,: ,_..
0 0 0 0 49 ~ad 0 94 0 5b 3 aG 80 3d 0 . ..:c~~. . . , L .;.-, 70 0 5b 3 0 40 ad 0 3c ,0 5b 3 4 0 da p,-I,[.;Q,.<.[.....
o 'o 0 0 1 0 . .o o ~ o o,. o sa 4o Ga o . . . . . . . . \~. . , a4 0 5b 3 be 80 3d 0 4 0 da 0 8 0 da 0 .,L...,=.,.-..:;, 1 0 0 0 Sa 40 cd 0 cc 0 Sb .3..'8 81 3d 0 ,.,,\t~;...(.,w=.
0 0 0 0 0 0 0 0- 0 0 0 0 0 0, 0 0 .... , ......
Heap Stack:
Length=8 0 0 0 0 67 41 cd 0 0 0 0 0 0 '0 0 0 ....gA..........
******************************************************************************

TP: 003D8108(o~~set 184) BP: 035BOOE4 SP: 035BOOE4 HP: OODA0008 Next Tnstruction: block 2,003D8AE8 Code Stack:
Length=e0 1 0 0 0 0 40 cd 0 4 0 5b 3'50 80 3d 0 .....C.....[.P.=.
0 0 0 0 0 40 ed 0 4 0 Sb ' 3 0 0 da 0 . ....Cn~.... j.. : . .
0 0 0 0 1 0 0 0 1 'a a o o ~o c~. o ...:.....:.:.~;.
x4 0 5b 3 64 80.34 0 .0 0 da 0 4 0 da 0 ..[.d.=. ...
1 0 0 0 0 40 cd '0 3c '0 Sb 3 78 $0 3d 0 .....C~.:<. j.zc.=.
1 0 0 0~ 1 0 0 0 0 40 cd 0 S4 p Sb 3' . .. :'.Q.,T.j.' 84 80- Sd 0" 0 0 p 0 l> 0 0 0, 0 40 Gd' 0 _. ..,.. ..Q...,.
68 O,Sb 3,8c 80 3d 0 ..0 0 '0 0: 1 0 0 0,kz.j,...=........:
p 0 40 cd .df'7a 0'Sb 3 a4 80.34 0 .....t~.-.~.(...~.
7. 0 .0 0 0.40 ad ::0 94 ::0 Sb 3 ae 80 3d '0 :.Q....[,.._.
7a .0 5b -,3 0 40 act Q 3e 0 Sb -3 4' 0 da fJ- I . [..C~:.~. [..
0 0 ' 0 0 1 0 0 ',.. 0 ~. -., 0 0 , 0 5c 40 c~...: 0 . , . . : . \Q. .
a~#' . 0 Sb 3 be '80 3d 0- -4 0 4a 0 8 '' 0: da Q, :-: [. . ._.::.. .
Z O c 0 0 -50 40 cd- 0 Cc 0 5b 3 8 SI 3d 0 ....\C~.....[..._.
0 0' 0 0. 0 0 ~0 0 0~".0 0 0 0 0 0 0 ... ..,.
Heap St2:ak:
Length=8' 0 0 0 -0 67 -47. -cd 0'. Q 0 ~' 0 0 -.0 0 0 _. , , .gA . - . . . . , ' .
****,r*********;*******************~:********~*;******~~~*******r**************
****, -.
IPc 0031~80HC(o~fset 108), ~P: 035BOOCC SP:r 035BOOCC HP: OOAAQ008 Next Tnstruot'~.oz~: pattern match ox collect 0 Code Stack:
Length=GS
1' 0 0 0 0:"40 cd 0 4 0 5b 3 5D 80 3d 0 .<...i~:,..[,P
0 0 0 0 0.-40 ad~-0 4 0 5b 3 0 0 da 0 .. ..C~...,[~,...
0 0 0: 0. l 0 0 ~., 1 0 0 0 0 40 cd 0 ..... ..,,C~.
4~
14 0 Sb 3 E4 ,80 3d 0 0 0 da 0 4 0 da '. Q . . j,d.=. . .'.: .-. . .
1 0 0 0 0 40 cd 0 3c 0 5b 3 78 80 3d 0 .....C~..<.[.x.=.
1 0 0 0 1 0 0 0 0 40 ad 0 54 0 Sb 3 .... :,C~..T.[.
$4 $0 3d 0 0 0 0 0 1 0 0 0 '0 40 cd 0 .. ...... :.C..
68 0 Sb 3 $a $0 34 0 0 0 0 0 1 0 0 0 11.j..._.........
1 0 0 0 0 40 Cd 0 70 0 5b" 3 a4 80 3d 0 .....Q..~,j...=.
1 0 0 0 0 40 cd 0 94 0 5b 3 ao 80 3d 0 :.....t~....[..._.
7c 0 5b 3 0 40 ed 0 3c 0 5b 3 4 0 da 0 ~.(..~..<.[. "..
0 0 0 0 l 0 0 0 1. 0 0 0 Sc 40 cd 0 a4 p 5b 3 be 80 3d 0 0 0 0 0 0 0 0 0 .,[.:-:--...:......
Heap Stack;
Length=8 0 0 0 67 41 ed 0 0 '0 0 0 0 0 0 0 ....gA..., ..
******************************************************************************
rP: 003D$OAG(offset 92) BP: 035BOOA4 .-SP: o3SB00A4 HP:,OODAOOO4 Next Instruction:: match child 2:: name Code Stack:
Length=a0 . .
1 0. 0 05 0 40 ed 0 4 0 5b 3 50 80 3ci. 0 . ,:e....[:-P.=.
0,.0 0 0 0 40 ed 4,. 4 0 5b 3 0 ,0,da 0 . ..~....:[.
0 0 0 0 2 0 0 0 ~.. 0 0 0 0 40 ad :.~ ... .....c~..
14 0 5b ~ 64 $~ 8d 0 O 0 da 0 4 0-da 0 .~[.d.=.,.:.....
1 0 b, 0 0 40 cd 0 3c 0 5b 3 78 80'3d 0 . ..~..<.[.x.=.y 1. 0 0 0 1 0 0 0 0 40 cd . '0 54 0 Sb 3' ,~ . . . . . . '.c~: ,T. [. ,.
84 80 3d 0 0 0 0' 0 1' 0 '0 0 0 40 cd p .. . ...,C~.., . ; _, ,- , 68 0 5b 3 BC 80 3d '_0 0 . -Q 0 0 1. 0 0 '0 h. [, ,'a=. . , . . . . .:~.
1 0 0~~ 0 0 ~°~'0-. cd 0 .'Tc 0 5b - 3 a4' a80~ 3d 0 , . , f~.'. ~-. [
. . . _.
1 0 -0 0 0 40 cd 0 94' 0 Sb 3: ac $0 3d 0 . :..C~....(.,_, 0 0 -0 0 0 0 0 0 0 ~ 0 ~ 0 0 0 '0 ..... ..
Heap, Sack:
Length=4 0 0 0 0: 0 0 0 0 4 0 0 0 0 0 0 0 ..... ..
******************~'******************.**************~'*******************:~***
***
IP: 043D$OA4(offset 84[ :. BP:03SB0094 SP: 93580094' , HP: OO~A0004 Next Tnstruation: try 9c Code'Staek:
Length=90 a. o a, a p 4~ ..Cd o 4 '. a ~b ~ so' sa sd a :....~ . : [.P.=, , 0 0 0 0 040 Gd 0 4' 0 5b 3 ' 0 O da 0 . ..Q....[.....
0 0 0 0' 1 0 0 0 ~: 0 0 0 0.40 cd 0 ..,.....Ø,-14 0 5b 3'.64 80 3d 0 0 0 da 0 ,4 0 da 0 ..[.d.=....,;...
1 0 0 0 0 40 cd 0 3c 0 5b 3 78 80 3d 0 ....,f~..~.[,x.=.
1 0 0 0 7. 0 0 0 0 40 cd 0 54 0 5b 3 . ....~..T.[.
$4 80 3d 0 0 0 '0' 0 Z 0. 0 0 0 40 od 0 :. ..........~..
sa o sb 3 ac so 3d a o 0 0 0 2 0 0 o h.[.,._.........
1 0 0 0 0 40 cd 0 7c 0 5b 3 a4 80 3d 4 .....@..~.[..._.
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ........... , Heap stack: -Length=4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...... ......
******************************************************************************
IP': 003D$OEC(offset 1.56) BP: 035B007C SP: 035B0080', HP: OODA0004 Next Instruction: replay 0 ' Code Stack: ' Irength=7 c I: 0 'D 0 0 40 ad 0 4 0.5b 3 50 80 3d 0 . ..~....[':P.=. , 0 0 .0 0 - 0 40 ad . 0 4 0 5b 3 0 0 da' 0 . :.Q ., [.....
0 0 0 0 ':1 0 0. 0 1:''0 0 0 0 40 Cd. 0 . ..... :.Q..
14 0 5b 3 64 $0 3d 0 0 0 da 0 4 0 da ,~ ..[.d:=...:...,.
1'.rO 0 0 - 0 4D cd .0 3c 0 5.b 3 78' $0 3d 0 . .,c~..~. ~.X.=.
d 0 p y Q 0 ,p 0 40 cd 0 54 . 0 Sb $ . . ..t~, .T. [.~v $4 80'34 0 0 0 0 0 ' 1:- 0 0: 0 0 4Q ed 0 .. .... ..C7.. , 68~x- D- Sb' 3 $a -80 3d D- D 0 . D 0 Q 0 ,~9 d lz,. [.:._.:~....'.;.-Heap Staak:
Length=4 0-,<0 0 D 0 .'0 0 0 -0 ~ 0 0, 0 0 0 0 i~",.. ......
*******,r**********a************x****************************~c****************
*
I2: 003DSOF4(of~set x.641 BP: 03580098 S2: 035B009g NP: OD'DAD004' Next Iiistruct'ion: pattern match Cede Stack.:
Length=94 I 0 ' 0 0 0 4D ed 0 4 D 5b 3, SD~ $0 3d D .. .:C~.,.. [.p.~
0 0 D D '.'D 4p ed -0 ~ 0 5b.,3 -0 0 da 0 . ..:'C~..;.[...,.
o .0 0 0' ~, o 0 o i o D o '0 4o cd, o .. :. ::~..
~,4 ., 0 5b ~ 64 '$0 3a o o , 'o da o 4 o as o ';d.-: . . . ~. . . . . ' 1 0 0 0 0 40 ad 0 3c' 0 5b . 3 7$ 80 3c1. 0 . ..~..~,[.x,y, I Qv 0 0 '.a,. 0 0 0 0 40 cd 0 54 ;:0 5b ':3 ,, ...:C,.T.[, $4 BQ 3d 0 0 0 0 : 0 i 0 0 0 .:0 40 'Gd 0 .. ,. ...,...Ca7., n68' D 5b 3 80'!,80 3d :~0 D 0 0 0 0 0 0 0 h. [ , :'. _: , . . , , . . .
4 0 da D 1 0 0 0 0 40 ad 0:7c 0 5b 3 ....,..,.C~..~.[~
ec 80 3d 0 - 0 0 D 0 0 0 0 0 0 0 D 0 .. ...... .....
Heap stack:
Length=4 0 0 0 0 0 0 0 0 0 0 0 0 0 '0 0 0 ..........,.....
******************************************************************************
IP: 003DSOEC(offset x.56) BP: 0358009$ SP: 03580098 HQ: OODP,0004 Next Instruction: replay 0 ', Code Stack:
Length=94 1 0 0 0 0 40 cd 0 4 0 5b 3 50 80 3d 0 ....:C~:...[.P.=.
0 0 0 0 0 40 cd 0 4 0 5b 3 0 0 da 0 . ..Q....L.....
0 0 1 0 0 0 1 0 0 0 0 40 ~d 0 ..........Ø, 14 0 5b 3 64.80 3d o' 0 0 da 0 4 O da 0 ..C.d.=.........
1 0 0 0 ~ 40 cd Q 3c 0 5b 3'78 80 3d 0 ,. .,(~.,<,[',x.=::
0. 0 0 1- 0 0 0 0 40 cd '0 54 0 Sb 3 ,.......,.0'..T.[.
84 80 3d. 0 0 0 ~ . Q 1 0 0 -.0 0 40 Cd 0 ,. .. . . . . . ,(~. .
68 0 5b 3 8c 80 3d 0 .0 0 0 0 0 0 0 0 Yi'::[.,. ....
4 0 da 0 1- 0 0 0 0 40 ed 0 7c 0 5b 3 ... . ...'~..~.'[:.
ac 80 3d 0 0 0' 0 0 0 0 0.'0 0 0 0 0'. ~..., .... .
Heap Stack:
Length=4 o ,' 0 0 0 . 0 0 0 0 '0 0 :0 0 0 0 0 .. . . , ..
************~**'***************************'******~****************;*****~*;***
**
IP; 003D808C(offset 60) BE: 0358007C SP: 035B007C HP: OODA0o04 Next Instruct'zan: pa~'am blank Code Stack:
lren~th=78 ~:
1 0 0 .:. ~ 0 40 Cd ° ~_ 4 0 5b 3 50. 80 3d_ 0 ...,.t~....,j.P:=. -.
p o p 0 ; 0 40,cd 0 4 0 5b 3 ' 0 0 da 0 .....~a.,s...[...,~ .
0 0 0 0 1 0 0 o x o o .0 0 4o ed o, ..,.......,..ca..
14', 0 5b .3 64 80.3d 0 0 0 da ,0 4 0 da o ,.[,d.=.,,.,.,.
1 a 0 ~- 0''40 ed- 0 3c 0 5Ja 3 78 ~80 3d :0 ....r:t~..<.{.x,=, 0 .~ Q ,1 0 0 0 0 4Q cd :0'S4 0. 5b 3 ..,. ..(s~,,T.[.
84, '80 3d- ~'0 0 0 0 p 1 0 0 ;:::Q 0 40 Cd 0 .~. .=. . . . . . . : , .C~.
6g 0 Sh 3 8c 80 3d 0 0 0 0 0 0 0 0 0 h. [.. .
Heap,Stack:
Length=4 0 0 o o ,, p 0 0 0 0 0 0 0 0 0 0 0 , ... .
******~r***********************~~************~:********'***********************
**
TP: 003D'8084(Qtf'set 52) BP:,035B0,o68 SP: 03580068 HP: OODA0004 Next Tnstruatic>n: try b4 Code Stack:
Length=64 1 0 0 0 0 40 cd 0 4 0 5b 3 50 80 3d 0 . ..Q.,..[.P.=.

0 0 0 0 0 40 cd 0 4: 0 Sb 3 0 0 da 0 ....Ø,..f,,...
0 0 0 o i o a o 1 0 0 0 0 4o cd o :.,..........c~..
14 0 5b 3 64 80 3d 0 0 0 da 0 4 0 da 0 ..[.d.=.........
1 0 0 0 0 40 cd 0 3c 0 Sb 3 78 80 3d 0 .....Q..<.[.X.=, 1 0 0 0 1 0 <0 0 , 0 40 cd 0 54 0 5b 3 . ......C~2..T. [.
84 80 3d 0 0 0 0 0 0 0 0 0 0 0 0 0 Heap Stack: ' Length=4 0 0 0 '0 0 0 0 0 0' 0 ~ 0 0 0 0 Q . ,.., ...
***************************'**********************;r********~**********~*******
~
TP: 003D8104(offset 180) HP: 03S&QOS4 SP: 03680054 ATP: OODA0004 Next Tnst~ua~ion:,, return Code Stacka:
Length=50 1 0 'p ,.p .0 40 ed 0 4. 0 5b 3 50 8p 3d 0......t~..:.f.P,=.
0 0 0 ,0 40 ad';.0 4 0 Sb 3 ~,:0 da 0 . :,C,...:'I.,.,. ' ~.,, (j. 0 0 0 . 1 0 0:.' 0 1. 0 ' 0 0 0 40 cd 0 . . , . , . . . . ~,,c~, . , 0 5b "3 64 80 3d 0 0 _:.0 da 0 4 0 da 0 '.-. f,d.=...,.......
1 0 0 0 ~ ~~ cd 0 3'c- 0 Sb : 3 78 So 3ia. 0 , . . > .~. ,'<: [.x,=: ,' 4 0 0 , 0 0 0',:0 0 0 , 0. 0 0 4 0 0 . ......
Heap Stack:
Length=4' 0 '0 0 - 0 0 0 0 , 0 0 0 '. 0 0 0 0 0 0 . . . . . . . . . .
***********************,**********'*********~*********~************.***********
*~
IH: 003A8078(o'ffset-CFO) BP:.03'SB0054 ': S2: 03580p54 HP:. OODA0004 Next Tnstruction: block 2~003DgDC8 Code Stack:
Length.=50 0:'0 =0 0 40 ~ 0 4 0"5b 3 50 :80 3d-..0 .....c~....f.P.=. , 0 0 0 0 0 40 Gd 0 4 <0 Sb 3 0 0 da 0.'.. ,.~....[,..., 0 -0 0 0 1 0 0 0 1 0 0 0 0 40 ed 0 ...,...,.....CS..
14 0 5b 3 64 80 3d 0 0 ,0 da 0 4 0 da 0 :.f.d._.......,.
1 0 0 0 0 40 cd 0 3c 0 Sb 3 78 80 3d 0 : ..~..<,[,x.=, 0 0 0 4 0 0 0 0 0 0 '0 0 0 0 ,0 0 ................
Heap Stack:
Length=4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ..........'......
******************************************************************************

1P: 003D8064toffset BP: SP:035BOp3C HP: OODAppp4 20) 035B003C

Next Tnstruction:pattern match Code Stack:

Length=38 1 0 0 0 0 4~0' 0 0 5b 50803d0'.....C~.... [.P.=.
cd 4 3 0 p p 0 0 40 p 0 5b 0 0 da0 .....C~....[.:..
cd 4 3 0 0 0 0 1 0 0 0 0 0 40cd0 ..... .....Q.. -14 0 5b 3 64 0 0 p' 0.p .,-p0 ..[.d;,:=........
80 3d' 0 0 Heap Stack:' ' Length=4 p p p p p p o 0 0 0 0 p . . . . . .
0 . '.

*****************~*.'***************************;*~*~*******~*****************~

TP: O;p3D805p(ofsetBP:035Bp014S P:035Hp024 0) .
HP:
OOD.F~pOpO-Next.Snstxuction''b~.ock Qpp O~OOO00 Code Stank:

Dez~gth=10 ~. 0 0 0 0:-4p 04 0 5b SO$03d: .....c~.... I.P.=.
ad ' 3 Q

4 0 0 0 0 0 0 p 0 p 0 0 ~ . ..... ...
' p 0 ~

Heap Stack:

Length=0 o 0 0 0 0, :o 0 o o ;;pp p ',, . .. ...
-o 0: Q p

Claims

1. A method of processing one or more XML documents where the processing includes a plurality of stylesheets using an abstract machine, such method comprising the steps of:
reading a stylesheet of the plurality of stylesheets;
compiling the stylesheet into a set of abstract machine instructions specialized for stylesheet processing; and executing the instructions on the abstract machine.

2. The method of processing the XML documents as in claim 1 further comprising compiling a plurality of blocks of abstract machine instructions for the compiled stylesheet.

3. The method of processing the XML documents as in claim 2 further comprising compiling a backtracking abstract machine instruction for each block of the plurality of blocks.

4. The method of processing the XML documents as in claim 3 further comprising resetting a code stack and a heap stack upon processing completion of each block of the plurality of blocks.

5. The method of processing the XML documents as in claim 4 further comprising calling a block of the plurality of blocks via a pattern matching instruction.

6. The method of processing the XML documents as in claim 4 further comprising calling a block of the plurality of blocks via a direct call instruction used to call a named template.

7. The method of processing the XML documents as in claim 4 further comprising calling a block of the plurality of blocks via a pattern match for imports which calls a template that can match with a lower import precedence than a current template.

8. The method of processing the XML documents as in claim 4 further comprising calling a block of the plurality of blocks via an external function call.

9. The method of processing the XML documents as in claim 1 wherein at least some of the set of abstract machine instructions further comprise abstract machine instructions for tree searches of an XML document.

10. The method of processing the XML documents as in claim 1 wherein at least some of the set of abstract machine instructions further comprise abstract machine instructions for storing and manipulating the results of tree searching an XML document.

11. The method of processing the XML documents as in claim 10 further comprising using a transform allocator to store tree fragments constructed across many template invocations.

12. The method of processing the XML documents as in claim 1 wherein the step of executing the instructions on the abstract machine instructions further comprises maintaining XSLT template invocation state using a memory stack.

13. The method of processing the XML documents as in claim 1 wherein the step of executing the instructions on the abstract machine instructions further comprises providing a transform allocator storage area for maintaining temporary data for processing.

14. The method of processing the XML documents as in claim 1 further comprising providing a memory stack for maintaining variable length data of the abstract machine.

15. The method of processing the XML documents as in claim 1 wherein the step of compiling the stylesheet further comprises identifying a type of each data value used in the stylesheet.

16. The method of processing the XML documents as in claim 11 wherein the step of identifying a type of each data value used in the stylesheet further comprises generating an abstract machine instruction appropriate for processing the identified data type.

17. The method of processing the XML documents as in claim 1 wherein the step of executing the abstract machine instruction set in the abstract machine further comprises processing a representation of an XML document.
42~~

18. An apparatus for processing one or more XML documents where the processing includes a plurality of stylesheets using an abstract machine, such apparatus comprising:
means for reading a stylesheet of the plurality of stylesheets;
means for compiling the stylesheet into a set of abstract machine instructions specialized for stylesheet processing; and means for executing the instructions on the abstract machine.

19. The apparatus for processing the XML documents as in claim 18 further comprising means for compiling a plurality of blocks of abstract machine instructions for the compiled stylesheet.

20. The apparatus for processing the XML documents as in claim 19 further comprising means for compiling a backtracking abstract machine instruction for each block of the plurality of blocks.

21. The apparatus for processing the XML documents as in claim 18 wherein at least some of the set of abstract machine instructions further comprise abstract machine instructions for tree searches of an XML document.

22. The apparatus for processing the XML documents as in claim 18 wherein at least some of the set of abstract machine instructions further comprise abstract machine instructions for storing and manipulating the results of tree searching an XML document.

23. The apparatus for processing the XML documents as in claim 18 wherein the means for executing the instructions on the abstract machine instructions further comprises means for maintaining XSLT
template invocation state using a memory stack.

24. The apparatus for processing the XML documents as in claim 18 wherein the means for executing the instructions on the abstract machine instructions further comprises means for providing a transform allocator storage area for maintaining temporary data for processing.

25. The apparatus for processing the XML documents as in claim 18 further comprising means for providing a memory stack for maintaining variable length data of the abstract machine.

26. The apparatus for processing the XML documents as in claim 18 wherein the means for compiling the stylesheet further comprises means for identifying a type of each data value used in the stylesheet.

27. The apparatus for processing the XML documents as in claim 26 wherein the means for identifying a type of each data value used in the stylesheet further comprises means for generating an abstract machine instruction appropriate for processing the identified data type.

28. The apparatus for processing the XML documents as in claim 18 wherein the means for executing the abstract machine instruction set in the abstract machine further comprises means for processing a representation of an XML document.

29. An apparatus for processing one or more XML documents where the processing includes a plurality of stylesheets using an abstract machine, such apparatus comprising:
a stylesheet processor adapted to read a stylesheet of the plurality of stylesheets;
a compiler adapted to compile the stylesheet into a set of abstract machine instructions specialized for stylesheet processing;
and an abstract machine adapted to execute the instructions on the abstract machine.

30. The apparatus for processing the XML documents as in claim 29 wherein the set of abstract machine instructions further comprise a plurality of blocks of instructions.

31. The apparatus for processing the XML documents as in claim 29 wherein each block of the plurality of blocks further comprise a plurality of instructions compiled together to use a common stack frame.