Free decompile java class file software for linux

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.

C# Java Virtual Machine is a tiny implementation of the Java VM, including simple native classes. This project is written using the C# language. The VM is very easily expandable by writing additional native or Java classes.
Enhancements:
- The DbConnection class, which provides a connection to MS SQL or PostgreSQL using ADO.NET, was added.
- The Syst.MachineName method, which returns the machine name, was added.
- String.startsWith and String.endsWith functions were added.
- Some comments for VM.cs were written.

MySpace Data Mining Tools are a set of Java classes designed to mine information from MySpace profile and blog pages using a multi-threaded Web page access method.
Enhancements:
- Direct database connectivity via JDBC was implemented for data storage.
- A basic user profile class was created to handle both user data compression and database access.
- Minor bugs were fixed for some of the raw data accessing routines.

Exception::Class::TCF is a Java/C++ style exception handling.

SYNOPSIS

try BLOCK [ [catch] NAME FUN_REF ]*
throw [ EXCEPTION LIST ]

package EnclosureException;
@ISA = qw(Exception::Class::TCF);

package main;

use Exception::Class::TCF;

try {
if ($Lost) {
throw new EnclosureException Message => "Help!";
}
else {
throw Error;
}
}
catch EnclosureException => sub {
warn "Message ",$_[0]->message," received.n"
},
Default => sub {
warn $_[0]->type, " exception ignored, trace:", $_[0]->trace
};

The Exception::Class::TCF module provides the possibility of executing a code block and specifying actions when different exceptions are raised. The try function takes as its argument a code block followed by a list of pairs of exception package names and function references, representing the action to take if a subclass of that package is raised. To increase readability the keyword catch may be inserted before any name-action pair. The return value of try is the return value of the block if no exception is thrown and the return value of the action of the chosen action in case one is found.

Even though the builtin die is used in the implementation any explicit use of die within the dynamic scope is ignored by the exception mechanism and thus works as usual. On the other hand an eval block will catch a thrown exception if it has not been caught by a try block. The clean-up routines after such a block may call throw as in the next section.

How to create an exception context.

An exception context in which thrown exceptions are handled is created using try as in

try { throw Error }
catch Default => sub { warn "Wow" };

The first argument is a code block (or a function reference). It will be referred to as a try block and any code executed inside it (including psossibly nested calls of functions in it) will be said to be in the dynamic scope of the block. After the try block follows a sequence of exception name - handling code pairs. The name will be referred to as the exception key and the corresponding code the handler (or catch handler) for that key.

An exception is either the name of a package inheriting from the package Exception::Class::TCF or an object blessed in such a package. In both cases the name of the package will be referred to as the name of the exception. All exception keys has to be names of exceptions except the special exception key Default which is the name for exceptions of package Exception::Class::TCF. In order not to clutter package name space, package names are normally prefixed by the Exception::Class::TCF:: prefix. To increase readability this prefix may be removed in exception key names and when calling throw with a package name as first argument.

The exception key may also be the string Finally. This does not correspond to an exception but instead its handler will be called just before the try function returns. Its value will be ignored however.

As new is a virtual function it can not be called with these shortened package names. For this on can use Exception::Class::TCF::make instead.

Class::Inner is a perlish implementation of Java like inner classes.

SYNOPSIS

use Class::Inner;

my $object = Class::Inner->new(
parent => ParentClass,
methods => { method => sub { ... } }, },
constructor => new,
args => [@constructor_args],
);

Yet another implementation of an anonymous class with per object overrideable methods, but with the added attraction of sort of working dispatch to the parent classs method.

METHODS

new HASH

Takes a hash like argument list with the following keys.

parent

The name of the parent class. Note that you can only get single inheritance with this or SUPER wont work.

methods

A hash, keys are method names, values are CODEREFs.

constructor

The name of the constructor method. Defaults to new.

args

An anonymous array of arguments to pass to the constructor. Defaults to an empty list.

Returns an object in an anonymous class which inherits from the parent class. This anonymous class has a couple of extra methods:

SUPER

If you were to pass something like

$obj = Class::Inner->new(
parent => Parent,
methods => { method => sub { ...; $self->SUPER::method(@_) } },
);

then $self-gtSUPER::method almost certainly wouldnt do what you expect, so we provide the SUPER method which dispatches to the parent implementation of the current method. There seems to be no good way of getting the full SUPER:: functionality, but Im working on it.

DESTROY

Because Class::Inner works by creating a whole new class name for your object, it could potentially leak memory if you create a lot of them. So we add a DESTROY method that removes the class from the symbol table once its finished with.

If you need to override a parents DESTROY method, adding a call to Class::Inner::clean_symbol_table(ref $self) to it. Do it at the end of the method or your other method calls wont work.

clean_symbol_table

The helper subroutine that DESTROY uses to remove the class from the symbol table.

new_classname

Returns a name for the next anonymous class.