Free xml output method software for linux

XML::Output is a Perl module for writing simple XML documents.

SYNOPSIS

use XML::Output;

open(FH,>file.xml);
my $xo = new XML::Output({fh => *FH});
$xo->open(tagname, {attrname => attrval});
$xo->pcdata(element content);
$xo->close();
close(FH);

ABSTRACT

XML::Output is a Perl module for writing simple XML documents

XML::Output is a Perl module for writing simple XML document. The following methods are provided.

new
$xo = new XML::Output;
Constructs a new XML::Output object.

open
$xo->open(tagname, {attrname => attrval});
Open an element with specified name (and optional attributes)

close
$xo->close;
Close an element

empty
$xo->empty(tagname, {attrname => attrval});
Insert an empty element with specified name (and optional attributes)

pcdata
$xo->pcdata(element content);
Insert text

comment
$xo->comment(comment text);
Insert a comment

xmlstr
print $xo->xmlstr;
Get a string representation of the constructed document

Smart Common Input Method platform is a development platform that significantly reduces the difficulty of input method development.
SCIM splits input method into three parts: FrontEnd, which handles user interface and communication with client applications, Server, which handles the key event to string conversion work, and BackEnd, which manages all of the Servers.
Enhancements:
- The implementation of scim::Socket was improved for better error handling.
- A high power consumption issue caused by the X11 frontend was fixed.

XML From Plain Text (xfpt) is a program that reads a file of plain text that contains relatively simple markup, and outputs an XML file. It is intended to simplify the management of XML data.
The project is not a program that attempts to turn a plain text document into XML. Markup within text is introduced by ampersand characters, but is otherwise "soft". You can define what follows the ampersand, for example, &" to generate a "quote" element. There is also a macro facility that allows for higher level concepts such as chapters, displays, tables, etc.
Enhancements:
- The macro library has been extended to include preface, appendix, colophon, footnote, figure, and table.
- The program has one new directive to enable it to handle "nested" sections such as footnotes.

XML::Mini::Document is a Perl implementation of the XML::Mini Document API.

SYNOPSIS

use XML::Mini::Document;


use Data::Dumper;


###### PARSING XML #######

# create a new object
my $xmlDoc = XML::Mini::Document->new();

# init the doc from an XML string
$xmlDoc->parse($XMLString);

# You may use the toHash() method to automatically
# convert the XML into a hash reference
my $xmlHash = $xmlDoc->toHash();

print Dumper($xmlHash);


# You can also manipulate the elements like directly, like this:

# Fetch the ROOT element for the document
# (an instance of XML::Mini::Element)
my $xmlRoot = $xmlDoc->getRoot();

# play with the element and its children
# ...
my $topLevelChildren = $xmlRoot->getAllChildren();

foreach my $childElement (@{$topLevelChildren})
{
# ...
}


###### CREATING XML #######

# Create a new document from scratch

my $newDoc = XML::Mini::Document->new();

# This can be done easily by using a hash:
my $h = {
spy => {
id => 007,
type => SuperSpy,
name => James Bond,
email => mi5@london.uk,
address => Wherever he is needed most,
},
};

$newDoc->fromHash($h);



# Or new XML can also be created by manipulating
#elements directly:

my $newDocRoot = $newDoc->getRoot();

# create the < ? xml ? > header
my $xmlHeader = $newDocRoot->header(xml);
# add the version
$xmlHeader->attribute(version, 1.0);

my $person = $newDocRoot->createChild(person);

my $name = $person->createChild(name);
$name->createChild(first)->text(John);
$name->createChild(last)->text(Doe);

my $eyes = $person->createChild(eyes);
$eyes->attribute(color, blue);
$eyes->attribute(number, 2);

# output the document
print $newDoc->toString();

This example would output :

< ?xml version="1.0"?>
< person>
< name>
< first>
John
< /first>
< last>
Doe
< /last>
< /name>
< eyes color="blue" number="2" />
< /person>

The XML::Mini::Document class is the programmers handle to XML::Mini functionality.
A XML::Mini::Document instance is created in every program that uses XML::Mini. With the XML::Mini::Document object, you can access the root XML::Mini::Element, find/fetch/create elements and read in or output XML strings.

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.

Business::Payroll is a series of Perl Modules that provides an API for working with multiple countries federal, state and local taxes.
Payroll Perl Modules project also supports calculating mileage reimbursement values and can handle adjustment entries.
The Business::Payroll module starts with an xml document in the Input format and if everything is successfull, outputs the results in the Output XML format.
Currently only the US is supported and MO is the only supported state. We are not supporting any cities in MO yet. Federal Income, FICA, Medicare and Mileage Rates are all being calculated. We take into account the number of allowances people can claim and the fact that you can withhold more for federal and state.
Federal Income tables are only available for any date >= 07/01/2001.
See the payroll_test.pl script and input.xml file for a sample implementation.
Use process_payroll (in the /usr/bin directory after an rpm install, otherwise in the payroll-x.y directory) to actually process payroll files for real.
process_payroll will take the specified raw xml file and process it. If no errors occured, then you get the result on stdout. If you specify 2 file names the result will go into the second file. You can specify - (for the first file) and it will know to work with stdin. I.e. you can pipe the file to be processed. Ex. cat input.xml | process_payroll - would process input.xml from the stdin and then output the result to stdout.
Enhancements:
- This release has been updated to cover the 2006 tax changes.

XML::Compile::Schema is a Perl module to compile a schema.

INHERITANCE

XML::Compile::Schema
is a XML::Compile

SYNOPSIS

# preparation
my $parser = XML::LibXML->new;
my $tree = $parser->parse...(...);

my $schema = XML::Compile::Schema->new($tree);

my $schema = XML::Compile::Schema->new($xml_string);
my $read = $schema->compile(READER => mytype);
my $hash = $read->($xml);

my $doc = XML::LibXML::Document->new(1.0, UTF-8);
my $write = $schema->compile(WRITER => mytype);
my $xml = $write->($doc, $hash);
print $xml->toString;

This module collects knowledge about a schema. The most important method is compile() which can create XML file readers and writers based on the schema information and some selected type.

WARNING: The compiler is implemented in XML::Compile::Schema::Translate, which is NOT FINISHED. See that manual page about the specific behavior and its (current) limitations! Please help to find missing pieces and mistakes.

WARNING: the provided schema is not validated! In some cases, compile-time and run-time errors will be reported, but typically only in cases that the parser has no idea what to do with such a mistake. On the other hand, the processed data is validated: the output should follow the specs closely.

Two implementations use the translator, and more can be added later. Both get created with the compile() method.

XML Reader

The XML reader produces a hash from a XML::LibXML::Node tree, or an XML string. The values are checked and will be ignored if the value is not according to the specs.

XML Writer

The writer produces schema compliant XML, based on a hash. To get the data encoding correct, you are required to pass a document in which the XML nodes may get a place later.

XML::LibXML::Enhanced is a Perl module that adds convenience methods to XML::LibXML and LibXSLT.

SYNOPSIS

use XML::LibXML::Enhanced;

my $xml = XML::LibXML::Singleton->instance;
my $xsl = XML::LibXSLT::Singleton->instance;

my $doc = $xml->parse_xml_string(" ");

my $root = $doc->getDocumentElement;

$root->appendHash({ name => Michael, email => mjs@beebo.org });