Free xml output java software for linux

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.

XmlAutoIndex (xai) is a module for Apache written in perl that browses your directories and outputs it into Xml.

The aim of this project is to replace mod_autoindex in Apache:
I would like to separate data from design, that is why I have made a xml output.

After that, using Xslt you can translate it into Html, Svg or Xul for example (you can make your own theme by updating xsl style sheet and with never touching the core engine).

Each plugins are indepentant and are here to generate thumbnails, previews, etc... Each previews, meta-data are cached in a cache directory to accelerate http queries. bonus: I have included in engine a handler that allows you to add comments per file, this behaviour does not require SQL server because comments are saved in files caches meta-data.

BNF for Java project is a parser/generator, or compiler-compiler. The parser reads your input text, or "terminals", specified by your BNF syntax.

The parser features indefinate look-ahead and back-track. As the grammar parses your file, it builds a parse-tree which carries the content in the structure of your grammar. Then the parse-tree is traversed, driving the output generators the you wrote in Java.

The compiler uses several files to control the project, so BNF for Java provides a Swing GUI to help you manage the BNF, Java, and XML files.

MikMod for Java is a Java port of the MOD player MikMod. It supports MOD, S3M, XM, MTM, and many other MOD formats.

The make file "source/Makefile" is intended for GNU make, so if its present you can just type make to build everything. The default java compiler name is javac, and if it isnt youll need to modify the makefile a bit.

Building the audio-driver is not trivial on a machine which isnt Linux. The makefile and and source files under the sub-directory source/dll can generate it on a Linux, but they need to be modified, and possibly re-generated by "javah" so theyll compile on another
platform. You can use the drivers in the MikMod for UNIX package to develop the native driver for your platform.

Both programs should be run from a command shell (they are Java applications that make use of the command line arguments). To invoke Java MikMod type:

java MikModApp [standard mikmod arguments]
and for Java mikcvt:
java MikCvtApp [file path]

Everything should work much like the C programs except that:

1. Output is not fully compatible.

2. Input is not available. (press Ctrl-C to abort the program).

3. It could be much slower.

SCAP-Java is an automatic thematical mapping software. It draws colors or symbol maps from your data, with step by step procedures coherent with the cartography semiology methodology.

SCAP-Java was developed for education and map production, with an emphasis on usability: its easy to create a PDF map from spreadsheet data and geospatial datasets (mif/mid).

Template::Plugin::Java is a Perl module that can generate Java Classes from XML description files and templates.

SYNOPSIS

From an xml file such as:
< aBean >
< java: option1="value1" >
< option2 >value2< /option2 >
< /java: >
< foo >10< /foo >
< bar >String< /bar >
< container >
< baz >20< /baz >
< /container >
< /aBean >

Through the program "tjava":

tjava [options] [file.xml ...]

Via a template, such as:

[% USE Java %]
package $package;

public class $class {

[% FOREACH Java.variables %]
$type $name = $initializer;
[% END %]

//... etc
}

To generated Java source code in the appropriate directory as determined by the package of the .xml files directory, specified package option if any, and CLASSPATH.

OPTIONS

Any options may be given besides those listed, these are passed directly to the Templates being processed in the stash (the variable table at time of processing). They can be given in the < java: > ... < /java: > section of an XML file (in which case, dont use the -- dashes) as attributes or elements, or on the command line.

--template

Name of the template to process. No extension is assumed by default unlike in the previous version.

--package

Destination package to put the generated classes, otherwise will be determined from how the current directory relates to the CLASSPATH.

--class

Class name to use, otherwise will infer from the root tag of the XML file.

--templatePath

Colon separated path where the templates can be found, overrides the environment variable TEMPLATEPATH. This doesnt work right now, so use the TEMPLATEPATH environment variable.

--genContainers

If set to 0, classes for subcontainers will not be generated. This is generally not useful.

--containerTemplate

By default set to Container, this is the default template, as well as the template used for sub-containers.

--containerNamePrefix

By default, if generating class Foo that needs to have a sub container wrapped in tag < bar >, its name will be FooBar. This is safe and wont cause collisions with different classes having sub containers of the same name (until some sort of dependency checking code is introduced). To turn this off, set it to the empty string "".

--interface

Interface to add to list of implemented interfaces, can be supplied multiple times. Make sure you append any necessary code to implement any of these interfaces.

--append

Text to insert in the generated class body.

--appendFile

Will insert text read from the file specified into the generated class body. This option and the --append option are mutually exclusive.

--file[s]

The XML file(s) to parse. This is useful for when the Plugin is instantiated from a custom script, not via tjava or inside a template.

Any other option will be placed into the stash for the templates to use, making tjava very useful with your custom templates.

Anything thats not an option will be assumed to be a file.

XML::Filter::Tee can send SAX events to multiple processor, with switching.

SYNOPSIS

my $t = XML::Filter::Tee->new(
{ Handler => $h0 },
{ Handler => $h1 },
{ Handler => $h2 },
...
);

## Altering the handlers list:
$t->set_handlers( $h0, $h1, $h2, $h3 );

## Controlling flow to a handler by number and by reference:
$t->disable_handler( 0 );
$t->enable_handler( 0 );

$t->disable_handler( $h0 );
$t->enable_handler( $h0 );

## Use in a SAX machine (though see L and
## L for a more convenient way to build a machine
## like this):
my $m = Machine(
[ Intake => "XML::Filter::Tee" => qw( A B ) ],
[ A => ">>log.xml" ],
[ B => *OUTPUT ],
);

XML::Filter::Tee is a SAX filter that passes each event it receives on to a list of downstream handlers.

Its like XML::Filter::SAXT in that the events are not buffered; each event is sent first to the tap, and then to the branch (this is different from XML::SAX::Dispatcher, which buffers the events). Unlike XML::Filter::SAXT, it allows its list of handlers to be reconfigured (via "set_handlers") and it allows control over which handlers are allowed to receive events. These features are designed to make XML::Filter::Tee instances more useful with SAX machines, but they to add some overhead relative to XML::Filter::SAXT.

The events are not copied, since they may be data structures that are difficult or impossibly to copy properly, like parts of a C-based DOM implementation. This means that the handlers must not alter the events or later handlers will see the alterations.