Free class file java software for linux

Class::Declare is a Perl module created to declare classes with public, private and protected attributes and methods.

SYNOPSIS

package My::Class;

use strict;
use warnings;
use base qw( Class::Declare );

__PACKAGE__->declare(

public => { public_attr => 42 } ,
private => { private_attr => Foo } ,
protected => { protected_attr => Bar } ,
class => { class_attr => [ 3.141 ] }
static => { static_attr => { a => 1 } } ,
restricted => { restricted_attr => string } ,
abstract => abstract_attr ,
friends => main::trustedsub ,
new => [ public_attr , private_attr ] ,
init => sub { # object initialisation
...
1;
} ,
strict => 0

);

sub publicmethod {
my $self = __PACKAGE__->public( shift );
...
}

sub privatemethod {
my $self = __PACKAGE__->private( shift );
...
}

sub protectedmethod {
my $self = __PACKAGE__->protected( shift );
...
}

sub classmethod {
my $self = __PACKAGE__->class( shift );
...
}

sub staticmethod {
my $self = __PACKAGE__->static( shift );
...
}

sub restrictedmethod {
my $self = __PACKAGE__->restricted( shift );
...
}

sub abstractmethod { __PACKAGE__->abstract }

1;

...

my $obj = My::Class->new( public_attr => fish );

MOTIVATION

One of Perls greatest strengths is its flexible object model. You can turn anything (so long as its a reference, or you can get a reference to it) into an object. This allows coders to choose the most appropriate implementation for each specific need, and still maintain a consistent object oriented approach.
A common paradigm for implementing objects in Perl is to use a blessed hash reference, where the keys of the hash represent attributes of the class. This approach is simple, relatively quick, and trivial to extend, but its not very secure. Since we return a reference to the hash directly to the user they can alter hash values without using the classs accessor methods. This allows for coding "short-cuts" which at best reduce the maintainability of the code, and at worst may introduce bugs and inconsistencies not anticipated by the original module author.

On some systems, this may not be too much of a problem. If the developer base is small, then we can trust the users of our modules to Do The Right Thing. However, as a modules user base increases, or the complexity of the systems our modules are embedded in grows, it may become desirable to control what users can and cant access in our module to guarantee our codes behaviour. A traditional method of indicating that an objects data and methods are for internal use only is to prefix attribute and method names with underscores. However, this still relies on the end user Doing The Right Thing.

Class::Declare provides mechanisms for module developers to explicitly state where and how their class attributes and methods may be accessed, as well as hiding the underlying data store of the objects to prevent unwanted tampering with the data of the objects and classes. This provides a robust framework for developing Perl modules consistent with more strongly-typed object oriented languages, such as Java and C++, where classes provide public, private, and protected interfaces to object and class data and methods.

Parse::Java is a Perl module that acts like a parser for Java code.

SYNOPSIS

use Parse::Java;

my $ast = Parse::Java->parse_file(MyClass.java);

Parse::Java parses Java code into an Abstract Syntax Tree which can be used for many things like writing compilers and stuff.

As this module is currently under development it isnt yet able to parse much Java. Whats in the t/*.t basically works but not much else.

The lexer should also more or less work fine except expansion of unicode escapes uNNNN.

INTERFACE

This module uses an object-oriented interface.

CLASS METHODS

parse_file ( $path )

Parses the contents of the file $path. Returns an AST representing the code.

parse_string

Parses the source in $string. Returns an AST representing the code.

detokenize ( $ast )

Walks the AST and replaces all Parse::Java::Token-objects with their stringified value.

INSTANCE METHODS

_set_input ( $source )

Sets the input to the lexer.

_next_token

Returns a list with the next token from the stream and its value.

jclassinfo reads java class files and provides information about the class, dependencies and more. It is a pure C implementantion.
Main features:
Class Information
- Java VM version required,
- super class,
- interfaces implemented. --general-info
- Constant pool dump --constant-pool
- Methods --methods
- Fields --fields
- Class attributes --attributes
Dependency Information
- Packages required --packages
- Classes required --classes
- Methods required --methods-ref
Options affecting verbosity
- Disassemble code --disasm
- Print limits and exception table for methods --verbose
- Print debugging information --method-debug-info
- Change visibility --visibility=< public | package | protected | private | synthetic >

Class::Declare::Attributes is a Perl module with Class::Declare method types using Perl attributes.

SYNOPSIS

package My::Class;

use 5.006;
use strict;
use warnings;

use base qw( Class::Declare::Attributes );

# declare the class/instance attributes
__PACKAGE__->declare( ... );

#
# declare class/static/restricted/etc methods of this package
#

sub my_abstract : abstract { ... }
sub my_class : class { ... }
sub my_static : static { ... }
sub my_restricted : restricted { ... }
sub my_public : public { ... }
sub my_private : private { ... }
sub my_protected : protected { ... }

Class::Declare::Attributes extends Class::Declare by adding support for Perl attributes for specifying class method types. This extension was inspired by Damian Conways Attribute::Handlers module, and Tatsuhiko Miyagawas Attribute::Protected module. The original implementation used Attribute::Handlers, but now simply refers to attributes.

The addition of Perl attribute support (not to be confused with object attributes, which are entirely different, and also supported by Class::Declare) greatly simplifies the specification of Class::Declare-derived class and instance methods. This should aid in the porting of existing code (Perl, Java and C++) to a Class::Declare framework, as well as simplify the development of new modules.

With the addition of Perl attributes, Class::Declare methods can now be written as

sub method : public
{
my $self = shift;
...
}
instead of
sub method
{
my $self = __PACKAGE__->public( shift );
...
}

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.

Scriptol is an object oriented programming language designed to deliver the programmer from hardware or software constraints and let him or her concentrate only on the problem to formulate as a program.

Scriptol Compilers is universal, and allows building dynamic Web pages (with PHP as the backend), writing scripts, and building binary applications. It is compatible with Java and C++ libraries. Examples of use with PHP, Java, and GTK are included.

How to install the Java extension for Php or C++

1) Installing Java for Php
Search for the java path, example:
c:jdk1.4

Search for the php extensions path, example:
c:phpextensions

The extension directory must hold these files:
php_java.dll
php_java.jar

Set these lines into php.ini (in the Windows directory)
extension_dir = c:phpextensions
extension=php_java.dll

Search for the [java] section in php.ini - java.class.path must be assigned the path of all jar or class files including php_java.jar, separated by a semi-colon. (You can use a dot to designate the current path for yours jar or class file) - java.home

must be assigned the path of Java. - java.library
must be assigned the path of jvm.dll. - java.library.path
must be assigned the path of php extensions, that hold php_java.dll and php_java.jar and the path of any Java class you want to use.

- If these classes are inside jar files, the jar filenames are a part of the path.
- If several paths are required, they are separated by semicolons and enclosed in double quotes.

Example:
[Java]
java.class.path = "c:phpextensionsphp_java.jar;c:myclasses"
java.home = "c:jdk1.4"
java.library = "c:jdk1.4jrebinclientjvm.dll"
java.library.path = "c:phpextensions;c:jdk1.4jrelib"

2) Installing Java for Scriptol C++
- The jvm.dll must be in the path.
- The jvm.lib, jni.h, jni_md.h files must be in the directory of the source.
- The JAVA_HOME variable must be assigned the path of the JDK (ex: c:jdl1.4).
- See the README file if you encounter problems...

UMMF::Export::Java is a code generator for JavaTemplate.

SYNOPSIS

use UMMF::Export::Java;

my $exporter = UMMF::Export::Java->new(output => *STDOUT);
my $exporter->export_Model($model);

This package allow UML models to be represented as Java code.