An API for reading and creating XML files. Examples for XML-Parsers with a SAX interface are Crimson and Xerces.

SAX2 defines standard methods to query and set feature flags and property values in an XMLReader. It is possible to change parser behaviors, such as requesting that an XML reader to validate (or not validate) a document, and register new types of event handlers using the getFeature, setFeature, getProperty, and setProperty methods:

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

When it comes to fast, efficient reading of XML data, SAX is hard to beat. It requires little memory, because it does not construct an internal representation (tree structure) of the XML data. Instead, it simply sends data to the application as it is read -- your application can then do whatever it wants to do with the data it sees.

This slide and the following from Alexandre Fayolles' excellent EuroPython 2002 tutorial on Python/XML processing is an great introduction to SAX processing in Python.

SAX. A download site for SAX. A tutorial introduction to SAX. Graphic formats. A large site which contains details of virtually all the graphic file formats.

The Simple API for XML or SAX is faster and more efficient than using the DOM. SAX is a Java based API that is very robust and effective. These SAX parsers make it easy for you to start using the Simple API for XML.

This project is an attempt to define an implementation of SAX using Objective C and Apple's Foundation framework. It may be portable with the GNUstep frameworks, though this has not been tested.

Most SAX parsers are built on top of a pull parsing layer. It is an interesting challenge to expose to the user both pull and push layers. This allows an application to use pull parsing when needed without having to stop using SAX API.

If a SAX application needs to implement customized error handling, it must implement this interface and then register an instance with the SAX parser using the parser's setErrorHandler method. The parser will then report all errors and warnings through this interface.

Parsing XML streams can be done with two different methods. They each have their pros and cons. Although the simplest, and probably most usual way to manipulate XML files is to represent them in a tree and manipulate it through the DOM interface (see next chapter).

The SAX2 interface is an event-driven mechanism to provide the user with document information. "Event" in this context has nothing to do with the term "event" you probably know from windowing systems; it means that the parser reports certain document information while parsing the document. These reported information is referred to as "event".

If a SAX application needs to implement customized error handling, it must implement this interface and then register an instance with the XML reader using the setErrorHandler method. The parser will then report all errors and warnings through this interface.

Each processing instruction the parser reads is passed to the processingInstruction() method in one invocation. This includes processing instructions that occur before and after the root element. The target is given as the first argument and the data as the second argument.

As a Software Consultant for companies such as IBM and Telxon, Shawn Van Dusen recently finished two large-scale projects, both of which included Sax ActiveX Scripting as an integral part of the program.

The SAX API for XML parsers was originally developed for Java. Please be aware that there is no standard SAX API for C++, and that use of the Xerces-C++ SAX API does not guarantee client code compatibility with other C++ XML parsers.

It's amazing what you can find in the back of your cupboard. Just last weekend, I found a half-bottle of an inexpensive 1991 Merlot that had gotten mixed in with the salad oil and vinegar bottles. How appropriate: Now I have some new red wine vinegar I didn't know I had! Well, we sometimes find old code lying around in the same way, and although it doesn't really spoil, it can get out of date.

Performance is a key concern in all types of applications, but in J2EE-based enterprise applications it can be especially pressing. With XML integration apps, one factor that always figures prominently in performance is the size of the document being manipulated. Simply put, a large in-memory DOM can impose huge demands not only on system memory but CPU time.

No SAX please we’re British [PDF]

We are switching to java to look at SAX event processing. The SAX parser treats the XML file and the tags within it as a series of processing events. In a simple file such as the Hamlet example the SAX parser could be told to look through the file until it encountered a PERSONA event. Once the event is encountered we can instruct the parser to do something with the element, the data and the attributes.