Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

openjava.mop.* (25)openjava.ojc.* (5)openjava.ptree.* (76)
openjava.ptree.util.* (10)openjava.syntax.* (21)openjava.tools.* (13)
openjava.tools.parser.* (11)

Package Samples:

openjava.mop
openjava.ojc
openjava.ptree
openjava.ptree.util
openjava.syntax
openjava.tools
openjava.tools.parser

Classes:

Metaclass: The class Metaclass is a metametaclass for metaclasses. You can write a metaclass easily using this class. For example, public class MyClass instantiates Metaclass extends OJClass { convenient void f() { .. String.class ..; .. oldjavaclass.String.class ..; } void g() { .. String.class ..; } } Here, you don't have to write constructors if your program don't concern. And class literal doesn't represent java.lang.Class object but openjava.mop.OJClass . The above code is to be translated into: public class MyClass instantiates Metaclass extends OJClass { void f() { .. openjava.mop.OJClass.forClass( ...
ExpansionApplier: The class ExpansionApplier is an evaluator of each objects of ParseTree family. Each methods in this class is invoked from the class EvaluationShuttle . The method evaluateDown() is invoked before evaluating the children of the parse tree object, and evaluateUp() is invoked after the evaluation. For a class P and a object p statically typed as P, the parts in source code each expantion will be applied are: Allocation new P() ArrayAllocation new P[expr] MethodCall P.m() , p.m() FieldRead P.f , p.f as a right side value FieldWrite P.f = expr , p.f = expr ArrayAccess ap[expr] for P[] ap; Expression ...
OJClass: The OJClass class represents a class metaobject. If the class has its valid .class file in CLASSPATH, the metaobject can behave like java.lang.Class . If the class has its valid .oj file in the packages where some classes are being compiled by OpenJava system, or in the packages explicitly specified by something like OpenJava compiler option or environment variable, the metaobject can have information about source code just as stamements, expressions, and etc. Additionaly, you can overrides the methods for introspection. OJClass[] getDeclaredClasses() OJMethod[] getDeclaredMethods() OJField[] getDeclaredFields() ...
UnaryExpression: The UnaryExpression class presents for an expression which consists of unary operator with one Expression. The unary expressions are : expr++ , expr-- , ++expr , --expr , ^expr , !expr , +expr or -expr ,where expr is an expression. If the operator in the expression of the operand has week unity, this automatically produces the code in which the operand is enclosed by parenthesises. In the case the operand is y = x and the urary operator is + , this produces the code : +(y = x)
ConditionalExpression: The ConditionalExpression class represents a conditional expression like: (i == 1) ? 3 : 4 This consists of a conditional part, true case part, and false case part. Each part of them is an expression. If the operator in the expression of the operands has week unity, this automatically produces the code in which the operands are enclosed by parenthesises. In the case the conditional part is f = f() , the true case part is "red" and the false case part is str = "blue" this produces the code : (f = f()) ? "red" : (str = "blue")
BinaryExpression: The BinaryExpression class represents an expression which consists of an operators and two operands. This doesn't includes the expression whose operator is the instanceof operator nor the expression whose operator is one of the assignment operators. If the operator in the expression of the left operand or the right operand has week unity, this automatically produces the code in which the left operand is enclosed by parenthesises. In the case the left is a + b , the operator is * the right is c + d , this produces the code : (a + b) * (c + d)
Statement: The Statement class presents common statement interface of parse tree. this interface is impelemented by EmptyStatement LabeledStatement ExpressionStatement (selection statement) IfStatement SwitchStatement (iteration statement) WhileStatement DoWhileStatement ForStatement (jump statement) BreakStatement ContinueStatement ReturnStatement ThrowStatement (guarding statement) SynchronizedStatement TryStatement
EvaluationShuttle: The class EvaluationShuttle is a Visitor role in the Visitor pattern and this also visits each child ParseTree object from left to right. The class Evaluator is an evaluator of each objects of ParseTree family. Each methods in this class is invoked from the class EvaluationShuttle . The method evaluateDown() is invoked before evaluating the children of the parse tree object, and evaluateUp() is invoked after the evaluation.
InstanceofExpression: The InstanceofExpression represents the expression like : obj instanceof Object If the operator in the expression of the left operand has week unity, this automatically produces the code in which the left operand is enclosed by parenthesises. In the case the left is obj = obj2 and the right is String , this produces the code : (obj = obj2) instanceof String
AllocationExpression: The AllocationExpression class represents an expression which allocates a new object with its constructor. This expression is like: new String( "test" ) or: new String( "test" ){ public void hoge(){ ... } ... } The latter is supported from JDK 1.1, is called an anoymous class of the inner class.
CastExpression: The CastExpression class represents a cast expression of parse tree. If the operator in the expression of the right operand has week unity, this automatically produces the code in which the right operand is enclosed by parenthesises. In the case the caster is int and the right operand to be casted is p + q , this produces the code : (int) (p + q)
Expression: The Expression interface presents common interface to access Expression node of parse tree this interface is implements by UnaryExpression BinaryExpression ConditionalExpression AssignmentExpression CastExpression AllocationExpression ArrayAllocationExpression Variable MethodCall SpecialName Literal ClassLiteral ArrayAccess FieldAccess
ExpressionObject: The Expression interface presents common interface to access Expression node of parse tree this interface is implements by UnaryExpression BinaryExpression ConditionalExpression AssignmentExpression CastExpression AllocationExpression ArrayAllocationExpression Variable MethodCall SpecialName Literal ClassLiteral ArrayAccess FieldAccess
ArrayAllocationExpression: The ArrayAllocationExpression class represents an expression which allocates a new array object. This expression is like: new Object[2][3] or: new String[]{ "this", "is", "a", "test" } The latter is supported from JDK 1.1.
FieldAccess: The FieldAccess class represents a field access like : f().str In this field access, you can get f() by getReferenceExpr() and can get str by getName() . Warning this class may has bugs around the expression.
ArrayAccess: The ArrayAccess represents an array access. An array access is like : a.m[i + 1] In this array access expression, you can get a.m by getReferenceExpr() and can get i + 1 by getIndexExpr() .
ParseException: This exception is thrown when parse errors are encountered. You can explicitly create objects of this exception type by calling the method generateParseException in the generated parser. You can modify this class to customize your error reporting mechanisms so long as you retain the public fields.
SelectionRule: The class SelectionRule represents selective syntax rule. Suppose there're several syntax rules; A, B, C. This class can represents the syntax ( A | B | C ). If both A and B are adaptable to token source, A is choosed since A is specified at lefter part than B's part.
ClassLiteral: The ClassLiteral class represents an expression as a object of Class class, which is suppoted since JDK 1.1. This is like : String.class or : int.class
PrepPhraseRule: The class PrepPhraseRule represents the syntax rule of a prepositional phrase. Suppose there's a syntax rule A and a given identifier i . This class can represent the syntax: PrepPhraseRule := i A
Parameter: The Parameter class represents parameter node of parse tree. Modifiers of parameter are supported from JDK 1.1. The code like: void test( final int i ){ .... } is allowed from JDK 1.1.
DebugOut: The DebugOut class is used to print something in debugging. No instance should be allocate and this class should be used statically. This class implements most methods of public printing methods found in java.io.PrintWriter, as static methods.
OJClassNotFoundException: The exception OJClassNotFoundException is thrown when an application tries to load in a class through its string name using forName method in class OJClass. but no definition for the class with the specifed name could be found.
CompilationUnit: The CompilationUnit class presents for the whole parse tree in a file. CompilationUnits consists of (package statement) (import statement list) (type declaration list) QualifiedName ImportStatementList ClassDeclarationList
SeparatedListRule: The class SeparatedListRule represents the syntax rule of a list separated by an separator. Suppose there's a syntax rule A and token t. This class can represents the syntax A ( t A )*.

Home | Contact Us | Privacy Policy | Terms of Service