Free xml files software for linux

f77xml/f90xml is a library that provides DOM parsing of XML files to Fortran 77/90. It acts as a wrapper between Fortran and the gdome2 library.

Installation:

The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.

Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, a file `config.cache that saves the results of its tests to speed up reconfiguring, and a file `config.log containing compiler output (useful mainly for debugging `configure).

If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.

If at some point `config.cache contains results you dont want to keep, you may remove or edit it.

The file `configure.in is used to create `configure by a program called `autoconf. You only need `configure.in if you want to change it or regenerate `configure using a newer version of `autoconf.

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.

If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute
`configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.

There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

XML Cleaner is a command line utility to filter and validate XML files.
XML Cleaner is written in Ada 9X and so it rather fast.
XML Cleaner is an XML filter and validator, similar to xmllint. It can remove superfluos namespace declarations from an XML file, expand XML entities, recode XML files, and more.
Main features:
- removes superfluous namespace declarations;
- Unicode support;
- (More to implement: XML validation, XML canonicalization, reformatting, whitespace removal, comments removal, XML charset recoding, XInclude processing, inplace file modification, etc.; XML Cleaner is to grow into a full featured command line XML filter and validator.)
XML Cleaner is developed to become xmllint replacement.
Enhancements:
- An option to choose whether or not to escape apostrophes and quotes in output was added.

tX, formerly known as Teddy, is a tabular XML editor. tX XML editor presents the structure and content of XML files in a way that is both visually pleasing and easy to use.
Its features include the abiltiy to view XML in an hierarchical way without extraneous syntax or interface elements, edit data like a spreadsheet, enter data without having to worry about encoding rules, make major structural changes with minimal effort, cut and paste between most spreadsheet applications, and export to HTML.
Main features:
- Teddy is now rebranded as tX - Tabular XML editor.
- Compilation under Qt4.
- Elements without subelements have a closing "../>" instead of .
- Attribute-value quotes changed from to ".
- New menu icons - some original, some from art.gnome.org.
- German language translation.
- A new tab called "Help Text" provides a generic help-system for XML-Files. In this tab it is possible to display user documentation: If either the working-directory or the directory of the current xml file has a sub-directory with the name of the DTD, a right-click on an element ( ) will load and display a file called "element_name.html" in the QTextBrowser-Widget. A right-click on the attribute (attribute-name="...") will jump to the "element_name.html#attribute_name" section of the html help file.

XML::UM is a Perl module to convert UTF-8 strings to any encoding supported by XML::Encoding.

SYNOPSIS

use XML::UM;

# Set directory with .xml files that comes with XML::Encoding distribution
# Always include the trailing slash!
$XML::UM::ENCDIR = /home1/enno/perlModules/XML-Encoding-1.01/maps/;

# Create the encoding routine
my $encode = XML::UM::get_encode (
Encoding => ISO-8859-2,
EncodeUnmapped => &XML::UM::encode_unmapped_dec);

# Convert a string from UTF-8 to the specified Encoding
my $encoded_str = $encode->($utf8_str);

# Remove circular references for garbage collection
XML::UM::dispose_encoding (ISO-8859-2);

This module provides methods to convert UTF-8 strings to any XML encoding that XML::Encoding supports. It creates mapping routines from the .xml files that can be found in the maps/ directory in the XML::Encoding distribution. Note that the XML::Encoding distribution does install the .enc files in your perl directory, but not the.xml files they were created from. Thats why you have to specify $ENCDIR as in the SYNOPSIS.

This implementation uses the XML::Encoding class to parse the .xml file and creates a hash that maps UTF-8 characters (each consisting of up to 4 bytes) to their equivalent byte sequence in the specified encoding. Note that large mappings may consume a lot of memory!
Future implementations may parse the .enc files directly, or do the conversions entirely in XS (i.e. C code.)

XML::EasyOBJ is an easy XML object navigation.

SYNOPSIS

# open exisiting file
my $doc = new XML::EasyOBJ(my_xml_document.xml);
my $doc = new XML::EasyOBJ(-type => file, -param => my_xml_document.xml);

# create object from XML string
my $doc = new XML::EasyOBJ(-type => string, -param => $xml_source);

# create new file
my $doc = new XML::EasyOBJ(-type => new, -param => root_tag);

# read from document
my $text = $doc->some_element($index)->getString;
my $attr = $doc->some_element($index)->getAttr(foo);
my $element = $doc->some_element($index);
my @elements = $doc->some_element;

# first "some_element" element
my $elements = $doc->some_element;
# list of "some_element" elements
my @elements = $doc->some_element;

# write to document
$doc->an_element->setString(some string)
$doc->an_element->addString(some string)
$doc->an_element->setAttr(attrname, val)
$doc->an_element->setAttr(attr1 => val, attr2 => val2)

# access elements with non-name chars and the underlying DOM
my $element = $doc->getElement(foo-bar)->getElement(bar-none);
my $dom = $doc->foobar->getDomObj;

# get elements without specifying the element name
my @elements = $doc->getElement();
my $sixth_element = $doc->getElement(, 5);

# remove elements/attrs
$doc->remElement(tagname, $index);
$doc->tag_name->remAttr($attr);

# remap builtin methods
$doc->remapMethod(getString, s);
my $text = $doc->some_element->s;

I wrote XML::EasyOBJ a couple of years ago because it seemed to me that the DOM wasnt very "perlish" and the DOM is difficult for us mere mortals that dont use it on a regular basis. As I only need to process XML on an occasionally I wanted an easy way to do what I needed to do without having to refer back to DOM documentation each time.

A quick fact list about XML::EasyOBJ:

* Runs on top of XML::DOM
* Allows access to the DOM as needed
* Simple routines to reading and writing elements/attributes

XML::QL is an XML query language.

SYNOPSIS

$ql = WHERE $head ORDER-BY $head IN "file:REC-xml-19980210.xml" CONSTRUCT $head;

print XML::QL->query($sql);

This module is an early implementation of a note published by the W3C called "XML-QL: A Query Language for XML". XML-QL allows the user to query an XML document much like a database, and describe a construct for output. Currently this module only offers partial functionality as described in the specification, and even some of that has been changed for ease of use. This documentation will describe the fuctionality of this module as well as differences from the XML-QL specification.

METHODS

query( "query" )

This is the only method required to use this module. This one method allows the user to pass a valid XML-QL query to the module, and the return value is the output.