Free java class filewriter software for linux

RJCE allows all methods or variables of user defined classes to be altered at runtime. These alterations are then applied to a single instance, a collection of instances (i.e. list, set or map), or an entire class.

This helps you to test your application in an interactive way; altering running programs helping a trial and error approach to programming; testing code and saving it when it’s correct. Long running algorithms, such as simulations, can also easily be refined without the need for restarts or lose of data.

RJCE can be used to write a program from within itself ensuring high coupling between testing and development, with no delay before the outcome of any alterations.

RJCE allows scripts to run from within your application, allowing users to configure or extend an application dynamically, bypassing normal language access rules controlled by public, private and protected. This can be done by easily instatiating an instance of CodeEditorFrame from the rom.gui package.

RJCE permits faster development of applications by allowing easy migration from scripts to Java programs.

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.

Java for C++ is a tool to generate C++-wrapper-classes for existing Java-classes. This tool reads a list of Java class names and creates source code for C++-classes to wrap them.
The implementation of the wrapper classes uses JNI (Java Native Interface) to call the "real" Java classes.
The C++-API to use these wrapper classes is very close to the API of the original Java classes. So developers of C++-software can use Java-classes as if they have been implemented in C++.
Enhancements:
- A problem where null values for method arguments, method return values, or field values caused some generated code to crash was fixed.
- Updating is strongly encouraged.

Claros Downloader is a simple, highly customizable, multi-threaded, web based downloader manager. You can download files to your desktop, corporate server, wherever you are. You simply point your browser to Claros Downloader, login, add new urls. It forks a new thread downloading the remote file to the server running the web application. Thats it.

Installation:

For Tomcat Users:

Copy the war file to $TOMCAT_INSTALL_DIR/webapps folder

Start Tomcat

For other application servers, you shall know what to do with a war file. If war extension means nothing to you, just unzip is it, if it was a regular zip archive.

All configuration is done in WEB-INF/resources directory. Open config.properties with your favorite editor, and follow the instructions.

Please Note: There is a Java class called AddUser.class in WEB-INF/classes/org/claros/downloader/admin directory. Run this class from console to add a new user to the system.

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 >

Inline::Java::PerlInterpreter is a Perl module used to call Perl directly from Java using Inline::Java.

SYNOPSIS

import org.perl.inline.java.* ;

class HelpMePerl {
static private InlineJavaPerlInterpreter pi = null ;

public HelpMePerl() throws InlineJavaException {
}

static private boolean matches(String target, String pattern)
throws InlineJavaPerlException, InlineJavaException {
Boolean b = (Boolean)pi.eval("" + target + " =~ /" + pattern + "/", Boolean.class) ;
return b.booleanValue() ;
}

public static void main(String args[])
throws InlineJavaPerlException, InlineJavaException {
pi = InlineJavaPerlInterpreter.create() ;

String target = "aaabbbccc" ;
String pattern = "ab+" ;
boolean ret = matches(target, pattern) ;

System.out.println(
target + (ret ? " matches " : " doesnt match ") + pattern) ;

pi.destroy() ;
}
}

WARNING: Inline::Java::PerlInterpreter is still experimental.
The org.perl.inline.java.InlineJavaPerlInterpreter Java class allows you to load a Perl interpreter directly from Java. You can then perform regular callbacks to call into Perl.

Java::Build::GenericBuild is a high level driver to control Java builds.

SYNOPSIS

There are two (or more) code files needed to effectively use this module. First, create a subclass of this class:

package Java::Build::MyBuild;
use Carp;

# Do the following in a BEGIN block before the use base statement:
BEGIN { $ENV{CLASSPATH} .= ":/path/to/suns/lib/tools.jar"; }
use base Java::Build::GenericBuild;
# use any other Java::Build modules you need

my @args = (
{ BUILD_SUCCESS => sub { croak "You must supply a BUILD_SUCCESS" } },
{ CONFIG_LOC => sub { croak "You must supply a CONFIG_LOC" } },
{ MAIN_DIR => &_form_main_dir },
# ...
); # Include all the attributes that matter to your build here, and
# what to do if the caller omits them.
# If they are required, die in the subroutine, otherwise provide a
# subroutine reference which will fill in the default

sub new {
my $class = shift;
my $self = shift;
$self->{ATTRIBUTES} = @attrs;
process_attrs($self);

return bless $self, $class;
}

# Include common targets callers can share here. Put unique targets
# in the calling scripts (see below).
sub init { my $self = shift; ... }
sub cvs_refresh { my $self = shift; ... }
sub compile { ... }
# ...
sub _form_main_dir { my $self = shift; $self->{MAIN_DIR} = /usr/src; }
In some script:
#!/usr/bin/perl
use strict; use warnings;

use Java::Build::MyBuild;

my $project = Java::Build::MyBuild->new(
BUILD_SUCCESS => /where/this/module/can/store/build/state.info,
CONFIG_LOC => /some/path/to/my.conf,
NAME => MyApplication,
SRC_DIR => /where/my/java/files/live,
SUBPROJECTS => [
{ NAME => "util" },
{ NAME => "app", USING => &compile_app },
],
);
$project->targets(qw( init cvs_refresh unique compile ));
$project->GO(@ARGV);

package Java::Build::MyBuild; # re-enter the build package to add targets
sub unique {...} # a routine that MyBuild doesnt provide

The Java Binary Enhancement Tool (JBET) is a general Java program analysis and manipulation tool. Existing class files can be disassembled, reassembled, or edited programmatically through the JBET API. JBET can also be used to create new Java class files from scratch. JBET uses a convenient internal representation of all the contents of Java binary (.class) files, allowing the user to edit the classes easily, in a structured manner.

JBET was developed as part of the DARPA Self-Protecting Mobile Agents project under the OASIS and Active Networks programs (contract number N66001-00-C-8602) in order to study automated software obfuscation.

The Java language was chosen for this project because of the (relative) ease of constructing binary editing tools provided by the large amount of type information present in the class files. Our two reports, the Obfuscation Techniques Evaluation Report, and the Obfuscation Report, are available from the download area. The obfuscation tool developed is not part of this release.

JBET was also used in the DARPA/AFRL Survivable Server project (contract number F30602-00-C-0183) to add additional security checks to the Java Standard Library. (The Java SecurityManager API does not support many desirable security checks, such as continued authorization of file accesses after opening.)

JBET was used to replace the native method references in the Java standard library with stubs that call a pluggable security policy. This tool, called Jpolicy, is also available for download at this website. Jpolicy is very incomplete at this time, but may be interesting to those working in Java security or changing the standard library themselves.

The internal representation of Java class files used by JBET is intented to make it easy for programmers to write Java binary code transforms. Each element of Java class files has a corresponding internal data structure: ClassInfo for entire classes, MethodInfo for methods, FieldInfo for fields, Snippit for code blocks, and Instruction for individual instructions. Snippit and Instruction understand Java opcode syntax and semantics, allowing automated creation of valid Java programs. A Java-compatible class verifier is also included.

Some code transforms are difficult to program directly by manipulating Java instructions. For those transforms, a directed acyclic graph (DAG) representation of code is available. In the DAG representation, each basic block has a corresponding DAG, with a set of input and output nodes. Edges in the graph connect "producer" nodes (such as constants, or the result of calculations) to "user" nodes (such as method calls or other calculations). Methods are divided into basic blocks and control flow is stored at the basic block level (possible because Java has only fixed jump targets)

JBET requires a Java 1.4 virtual machine to run, although it can operate on class files from earlier Java versions. The packaging and build environment supplied supports Linux and Windows with Cygwin; however, the build process is simple and could be performed manually on other platforms. Perl is required for regression testing.

Jpolicy requires a Java 1.4 virtual machine to build, either Linux or Windows NT/XP with Cygwin. gcc is required for building on Windows (supplied with Cygwin). The runtime system can be either Java 1.3 or 1.4 (with Suns JVM only), running on Linux or Windows NT/XP. Windows 9x and Windows 2000 may work as well, but have not been tested.

Installation

1. Install jdk 1.4.1.
2. Set CLASSPATH to jdk1.4.1/jre/lib/rt.jar
3. cd src; make
4. If that didnt work, examine the makefile. java or javac may not be in the path.
5. To build a jar file that can be used with "java -jar jbet.jar", run "make jar".
6. If you have perl installed, run the tests with "make test".
Optionally, run "make regen; make test".

Make a symbolic link from jbet3/bin/jbet to somewhere in your path.

Usage

JBET uses the JNI format for class names, and JNI type and method descriptors. For a summary of this syntax, use jbet help syntax. Suns JVM specification may also be helpful.

To look at a class disassembly, use jbet print. Try disassembling a class you have source for, and was built with debug info (-g): jbet -P < classpath > print < classname >. Suns JVM specification has an instruction reference.