Free dtds software for linux

mod_xmlns Apache module adds XML namespace support to publishing with Apache.
mod_xmlns adds XML Namespace support to Apache, and may form the basis of XML-driven publishing systems. It runs as an output filter, so it works automatically with any content generator.
From Version 0.9 (May 1st 2004) it has moved from experimental prototype to provisionally stable (i.e. theres nothing that is known to need changing before it can be declared stable). This hasnt entirely held, as the API has had to be updated. Now the API is shared with mod_publisher, and is being documented.
The basic API for Namespace implementations is:
- Create event handlers for your namespace.
- Declare your handlers in a struct xmlns.
- Make it available to mod_xmlns using ap_register_provider with provider_group=xmlns, provider_name=your_namespace and your choice of version string (see the XMLNSUseNamespace directive).
Directives implemented by mod_xmlns
XMLNSUseNamespace
Syntax: XMLNSUseNamespace URI [on|off] [version]
Activates or deactivates processing for namespace URI, using the processor defined in the version paramater.
XMLNSDefaultNamespace
Syntax: XMLNSDefaultNamespace URI
Sets a URI to use as default namespace (for un-namespaced elements).
XMLNSCommentHandlers
Syntax: XMLNSCommentHandlers on|off
Turns on or off comment handlers defined in namespace implementations. Default is On.
XMLNSCommentRemove
Syntax: XMLNSCommentRemove on|off
Determines whether to strip comments that are not processed by any namespace handler. Default is to pass comments through intact.
Version restrictions:
- mod_xmlns is a minimalist SAX parser, and has no support for DTDs and external entities, nor does it offer much scope for sanity checks on markup being processed. A compatible but richer companion module mod_publisher is in development.

Quanta Plus is a highly stable and feature rich web development environment. Quantas vision has always been to start with the best architectural foundations, design for efficient and natural use and enable maximal user extensibility.

We recognize that we dont have the resources to do everything we would like to so our target is to make it easy for you to help make this the best community based desktop application anywhere. Pretty much everything in Quanta is designed so you can extend it.

Even the way it handles XML DTDs is based on XML files you can edit. You can even import DTDs, write scripts to manage editor contents, visually create dialogs for your scripts and assign script actions to nearly any file operation in a project. You can even look at and communicate with a wide range of what happens inside Quanta using DCOP.

Quanta is based on KDE so this means it is network transparent from any dialog or project. It can use not only FTP but other KDE KIO slaves from file dialogs or in project settings. For instance if you want secure access try the fish KIO slave that uses SSH.

Just enter fish://[user]@domain in any dialog or select fish in your project settings. Here on this site you will find information on using Kommander to visually build dialogs you can extend Quanta with. These applications talk to each other using an IPC (Inter Process Communication) called DCOP (DEsktop Communication Protocol).

Of course I realize this can sound like alphabet soup techno-babble to some web developers, but heres what it means. When you are using Quanta and realize you would like to do something and you want to ask "Can I do this?" you can expect the answer will not only be yes, but it will probably be even cooler than you hoped for.

Not included on this site are other tools you can use with Quanta for revision control and reviewing and merging changes in files. Those applications are Cervisia and Kompare, and if they are not installed and you install them Quanta will use them.

We would like to think that there are rich rewards to be found here for those willing to explore new ways of doing things, or perhaps in some cases old ways that are just new to you.

Spumoni enables any program which can be queried via local commands to be health-checked via SNMP. This allows admins to use enterprise-level monitoring programs such as OpenNMS, Tivoli, OpenView, MRTG and RRDTool for even non-SNMP-enabled applications.
Spumoni acheives this efficiently using a native SNMP engine coupled with a stats collection daemon. Everything is highly configurable using modular XML files. Because of this modularity, the Spumoni project also contains a repository of configuration files to make monitoring various programs easier. A complete list of config files is available in the distribution package.
Main features:
- 100% Java means it can run on almost any platform.
- Licensed under the GPL. Special licensing also available.
- Low run-time utilization (only slightly more than your stats collection programs).
- Tested on Linux and Windows 2000.
- Uses a built-in SNMP daemon, so Net-SNMP is no longer needed.
- Includes an example MRTG front-end and a collection of monitoring config files to get you started.
Enhancements:
- Native SNMP TRAP and GET (agent) capability, thanks to JoeSNMP and Bob Sniders prototype code. This means that Net-SNMP, cfget and cfcat are no longer needed, so Spumoni runs just fine on Windows. Should make it more compatable on other platforms too.
- Added init.d-style startup script
- Added Windows batch file to run Spumoni
- Lots of code style standardization (thanks Checkstyle!)
- Tightened the XML DTDs
- Added CHANGELOG (this file)
- Added HTMLized source code to docs
- Added JUnit and Checkstyle Ant tasks
- Added JUnit and Checkstyle output to docs
- Greatly improved JavaDoc
- Improved build and versioning process
- Improved documentation & web site links

upCast enables you to use Microsoft Word as an authoring application for XML documents.
Take advantage of the widespread availability and familiar user interface of Word or any other RTF savvy office application for structured document authoring.
upCast offers a cost-effective way to reuse existing tools for gaining all the benefits of a standardized markup language: XML.
With upCast, you get the best of both worlds: excellent structural markup in XML and corresponding style information separated out in a CSS2 stylesheet. Proven upCast technology with built-in structure recognition heuristics preserves the document structure to an extent you wont be able to find anywhere else - instantly.
You can convert almost any document instantly without any time-consuming configuration. Yet, youll still get highest conversion quality - its really just a click on a button. Built-in customizations for specific DTDs like DocBook 4.2 help you use the product right out of the box.
upCast features a powerful, configurable batch conversion language. Select documents based on their name or extension, sort the resulting documents into specific folders and set filters and filter parameters.
A useful pre-scan feature tells you immediately which files are affected by your batch, so you can see at a glance if everything works as expected or if youre bound for trouble at some time in the conversion process.
A detailed log file tells you about the progress of the conversion as well as any errors that might have occurred. Combined with external commands and the built-in XML Validator and XSLT processor upCast turns into a flexible workflow automation tool.
upCast has a built-in slim, but efficient application programming interface (API). You can program against this API and thus include the complete functionality of our upCast Technology into your own applications.
By writing only a few lines of Java, C/C++ or VB code, you gain complete control over the document conversion process the same way as you would using the GUI. You can even create your own export filters in Java.
Version restrictions:
- 30 days evaluation DEMO
- With this evaluation version, the document text output will contain interspersed random characters.

x2svg is an application to graphically lay out files like DTDs and Java property files as scalable vector graphics (SVG). SVG diagrams can be converted into PDF files directly from within x2svg.

docbook2X is a software package that converts DocBook documents into the GNU Texinfo format and the traditional Unix man page format.
Notable features include table support for man pages, internationalization support, and easy customization of the output using XSLT. (Easy, because unlike other converters, the docbook2X stylesheets are written in a modular way, and the character escaping and whitespace issues with the man-page and Texinfo formats are encapsulated away from the user.)
Enhancements:
- Errors in the Man-XML and Texi-XML DTD were fixed. These DTDs are now used to validate the output coming out of the stylesheets, as part of automated testing. (Validation provides some assurance that the result of the conversions are correct.)
- Several rendering errors were fixed after they had been discovered through automated testing.
- Two HTML files in the docbook2X documentation were accidentally omitted in the last release. They have been added.
- The pure-XSLT-based man-page conversion now supports table markup. The implemented was copied from the one by Michael Smith in the DocBook XSL stylesheets. Many thanks!
- As requested by Daniel Leidert, the man-pages stylesheets now support the segmentedlist, segtitle and seg DocBook elements.
- As suggested by Matthias Kievermagel, docbook2X now supports the code element.

Polymorphic XML Parser is a validating XML parser for the programming language Objective Caml.
In October, 1999, I started writing a validating XML parser for OCaml; the first published versions have been called "Markup" (simply because the package name was "markup"). After this parser had some success, I decided to revise the whole code, and to redesign the parser where it was needed. The result of this work is PXP, the Polymorphic XML Parser. The name reflects an important property of the parser, namely that the type of the XML nodes can be customized; a feature which is missing in most other XML parsers.
Now, one year later, I can announce the first stable version of PXP. "Stable" means mostly that the interface of the parser has become stable, i.e. future changes will extend but not break the current interface. The parser worked relatively well from the very beginning, and during the pre-release phase (several months) users reported only few bugs. I am now relatively sure that PXP is mature enough to be used in applications.
In general, the task of a XML parser is to read XML text, and to represent the text somehow in memory. There are several models for the data structures; for PXP I have chosen the luxury representation as object tree, in which every XML node is stored as two objects. One object contains the set of methods describing the fixed properties of every node; the other object is called the extension object and can be configured by the user of the parser.
The extension object is the polymorphic part of the representation. The type of the class may be arbitrary (except three base methods which connect the object to the tree), and the parser has a mechanism to dynamically select the class of the object depending on the element type of the XML node.
Main features:
- The XML instance is validated against the DTD; any violation of a validation constraint leads to the rejection of the instance. The validator has been carefully implemented, and conforms strictly to the standard. If needed, it is also possible to run the parser in a well-formedness mode.
- If possible, the validator applies a deterministic finite automaton to validate the content models. This ensures that validation can always be performed in linear time. However, in the case that the content models are not deterministic, the parser uses a backtracking algorithm which can be much slower. - It is also possible to reject non-deterministic content models.
- The parser can read XML text encoded in a variety of character sets. Independent of this, it is possible to choose the encoding of the internal representation of the tree nodes; the parser automatically converts the input text to this encoding. Currently, the parser supports UTF-8 and ISO-8859-1 as internal encodings.
- The interface of the parser has been designed such that it is best integrated into the language OCaml. The first goal was simplicity of usage which is achieved by many convenience methods and functions, and by allowing the user to select which parts of the XML text are actually represented in the tree. For example, it is possible to store processing instructions as tree nodes, but the parser can also be configured such that these instructions are put into hashtables. The information model is compatible with the requirements of XML-related standards such as XPath.
- There is also an interface for DTDs; you can parse and access sequences of declarations.