Free xsd software for linux

pyXSD project is a free, open source python program that maps xml and xsd(XML Schema) files into python, allowing for easy schema-based validation and transformation of xml files.
Benefits:
- Allows for easy, non-DOM, access to XML and XML Schema from Python
- Minimizes time to make small programs associated with data in an xml file using "transforms"
- Highly adaptable to particular needs and to specific programs
- Its free!
- Platform independent
Main features:
- Transforms allow users to easily adapt pyXSD to vast number of applications
- Provides a framework and libraries to write transform so the user can more easily write these transform functions
- Allows the user to specify the desired transform classes with arguments and the order in a file so the user can create a sort of custom tool
- Allows for transforms that can export to other formats, giving pyXSD powerful flexibility
- The pythonic data tree format uses a very simple structure that allows for an easily understood API, so that users can easily manipulate this tree in transforms and use the writer in other programs
- Can be used as a standalone program at the command line or as a library in other programs
- Uses the cElementTree library for fast reading of the xml and xsd files

XSD/e is a XML Processing for Embedded Systems.
CodeSynthesis XSD/e is an open-source XML parser generator for mobile and embedded systems. It provides event-driven, stream-oriented XML parsing, XML Schema validation, and C++ data binding while maintaining a small footprint and portability.
XSD/e implements Embedded C++/Parser mapping which, provided with an XML instance specification (XML Schema), generates validating C++ parser skeletons for data types defined in your vocabulary. You can then implement these parser skeletons to build your own in-memory representation or perform immediate processing as parts of your XML document become available. For an introduction to the C++/Parser mapping, refer to the Hello World Parser chapter from the Getting Started Guide.
Based on the static analysis of the schemas, XSD/e generates compact, highly-optimized hierarchical state machines that combine data extraction, validation, and even dispatching in a single step. As a result, the XSD/e-generated parsers are 2-10 times faster than general-purpose validating XML parsers while maintaining the lowest static and dynamic memory footprints. For example, a validating parser executable can be as small as 120KB in size.
Main features:
- Ease of use The parser skeletons maintain parsing state and do data extraction for you. As a result, you are shielded from the intricacies of parsing XML.
- Validation The parser skeletons provide low-footprint, high-performance XML Schema validation so you dont need to complicate your code with extra error checking.
- Natural representation Handle the XML data using your domain vocabulary instead of generic elements, attributes, and text.
- Static typing The generated parser skeletons are statically typed which helps catch errors at compile-time rather than at run-time. For example, XML element and attribute names become C++ function names so if you misspelled one, the compiler will let you know.
- Concise code Thanks to the object representation provided by parser skeletons, your business logic implementation is simpler and thus easier to read and understand.
- Maintainability Automatic code generation minimizes the effort needed to adapt your application to changes in the document structure. Thanks to static typing, the C++ compiler will pin-point the places in your code that need to be changed.
Enhancements:
- Supported embedded toolchains include GNU g++ 2.95.x-4.x.x, eMbedded Visual C++ 4.0, and Visual Studio 2005 with Smart Devices support.
- Precompiled binary distributions are available for GNU/Linux, Solaris, and Windows host development platforms.

idl2xsd is an IDL compiler to W3C XML Schema.

SYNOPSIS

idl2xsd [options] spec.idl

OPTIONS

All options are forwarded to C preprocessor, except -b -h -i -q -s -t -v -x.

With the GNU C Compatible Compiler Processor, useful options are :

-D name
-D name=definition
-I directory
-I-
-nostdinc

Specific options :

-b base uri

Specify a base uri for location of import.

-h

Display help.

-i directory

Specify a path for import (only for IDL version 3.0).

-q

Generate qualified elements.

-s

Generate a standalone Schema (not only type definition).

-t

Generate tabulated XML (beautify for human).

-v

Display version.

-x

Enable export (only for IDL version 3.0).

idl2xsd parses the given input file (IDL) and generates :

a W3C Schema spec.xsd following the CORBA to WSDL/SOAP Interworking Specification (WS-I comformant soap binding).

idl2xsd is a Perl OO application what uses the visitor design pattern. The parser is generated by Parse::Yapp.

idl2xsd needs XML::DOM module.

idl2xsd needs a cpp executable.

CORBA Specifications, including IDL (Interface Definition Language) and CORBA to WSDL/SOAP Interworking Specification are available on http://www.omg.org/.

XSpyDer is XSD introspection in python.

The project is meant to create a dom representation of a XSD document with included types and create an intermediate representation that can create classes in other languages such as PHP, but also python, C, java, English.

wsdlpull is a C++ WSDL Library. wsdlpull project includes a WSDL Parser , a XSD Schema
Parser and Validator and XML Parser and serializer and an API for dynamic WSDL inspection and invocation.
wsdlpull uses the xml pull api to parse a WSDL1.1 document. This makes wsdlpull highly efficient which is why you can process and invoke a WSDL in no time.
The parser provides APIs to access various WSDL elements such as operations,messages,bindings,port types. Although wsdlpull is based on the pull parsing style of xml parsing the API is meant to be semantically as close as possible to the standard API for parsing WSDL, namely WSDL4J.
The invocation API allows you to dynamically inspect and invoke a web service. Unlike other toolkits there is no need to generate stubs or type serializers. Writing a web service client involves providing the WSDL URL ,setting the operation ,the input types and getting back the results in just one step.
The schema parser and validator provides an API for parsing XSD schema documents and validating their xml instance documents. The schema parser is used to parse the types section of the WSDL document.
The Xml parser and serializer provide a C++ implementation of the XML Pull API . WSDL processing, XSD schema processing ,creating SOAP messages all use the parser and serializer.
Enhancements:
- Several new features were added, including the ability to validate multiple occurences of choice elements, a new -p option to print port types of a wsdl, a -g option in the wsdl tool to generate soap message, and an experimental -g option in the schema tool to generate instances.
- Fixes were also made for a schema:import bug and for a type reference in an imported schema which is defined in same wsdl file but under another namespace.

XMLBeans project is a technology for accessing XML by binding it to Java types. XMLBeans provides several ways to get at the XML, including:
- Through XML schema that has been compiled to generate Java types that represent schema types. In this way, you can access instances of the schema through JavaBeans-style accessors after the fashion of "getFoo" and "setFoo".
- The XMLBeans API also allows you to reflect into the XML schema itself through an XML Schema Object model.
- A cursor model through which you can traverse the full XML infoset.
- Support for XML DOM.
Start off with your own stuff:
If you want to get right to it with your own XML schema and instance, follow these basic steps:
Install XMLBeans.
Compile your schema. Use scomp to compile the schema, generating and jarring Java types. For example, to create a employeeschema.jar from an employeesschema.xsd file:
scomp -out employeeschema.jar employeeschema.xsd
Write code. With the generated JAR on your classpath, write code to bind an XML instance to the Java types representing your schema. Heres an example that would use types generated from an employees schema:
File xmlFile = new File("c:employees.xml");
// Bind the instance to the generated XMLBeans types.
EmployeesDocument empDoc =
EmployeesDocument.Factory.parse(xmlFile);
// Get and print pieces of the XML instance.
Employees emps = empDoc.getEmployees();
Employee[] empArray = emps.getEmployeeArray();
for (int i = 0; i < empArray.length; i++)
{
System.out.println(empArray[i]);
}
Enhancements:
- Updated to the latest XMLSchema.xsd - January 25, 2006
- Updated XmlBeans to work with SaxonB-8.6.1 in place of SaxonB8.1
- XQuery external variable binding support

XML::Simple::DTDReader is a simple XML file reading based on their DTDs.

SYNOPSIS

use XML::Simple::DTDReader;

my $ref = XMLin("data.xml");
Or the object oriented way:
require XML::Simple::DTDReader;

my $xsd = XML::Simple::DTDReader->new;
my $ref = $xsd->XMLin("data.xml");

XML::Simple::DTDReader aims to be a XML::Simple drop-in replacement, but with several aspects of the module controlled by the XMLs DTD. Specifically, array folding and array forcing are inferred from the DTD.

Currently, only XMLin is supported; support for XMLout is planned for later releases.