| Home >> All >> de >> hunsicker >> [ jalopy Javadoc ] |
• de.hunsicker.jalopy: Javadoc index of package de.hunsicker.jalopy.
Package Samples:
• de.hunsicker.jalopy.swing.syntax: Provides some building blocks to make implementing a Swing-based, graphical user interface for the Jalopy code convention settings easy.
• de.hunsicker.jalopy.swing: Contains the main classes to directly interact with the Jalopy formatting engine.
• de.hunsicker.jalopy.language: Contains all classes related to the task of language recognition and processing.
• de.hunsicker.jalopy.plugin: Supplies the Plug-in hook for the integration with other Java applications.
• de.hunsicker.jalopy.storage: The Jalopy runtime and persistant state storage and configuration facility.
• de.hunsicker.jalopy.plugin.jedit.option: Contains the jEdit Plug-in.
• de.hunsicker.jalopy.printer: Provides classes and interfaces for handling the AST output.
• de.hunsicker.jalopy.plugin.ant
• de.hunsicker.jalopy.plugin.console
• de.hunsicker.jalopy.plugin.eclipse.prefs
• de.hunsicker.jalopy.plugin.eclipse
• de.hunsicker.jalopy.plugin.jbuilder
• de.hunsicker.jalopy.plugin.jdeveloper.message
• de.hunsicker.jalopy.plugin.jdeveloper.swing
• de.hunsicker.jalopy.plugin.jdeveloper
• de.hunsicker.jalopy.plugin.jedit
• de.hunsicker.jalopy.debug
• de.hunsicker.jalopy.prefs
• de.hunsicker.jalopy.plugin.netbeans
Classes:
• TreeWalker: Helper class to make implementing tree walkers easy. To implement a class that walks over all nodes simply dereive from TreeWalker and implement the callback method visit(de.hunsicker.antlr.collections.AST) 55 . class MyWalker extends TreeWalker { // called for every node public void visit(AST node) { System.out.println("node visited: " + node); } } If you want to control which nodes will be actually visited, overwrite walkNode(de.hunsicker.antlr.collections.AST) 55 too. // visits only IMPORT nodes and quits after the last IMPORT node found protected void walkNode(AST node) { switch (node.getType()) ...
• Jalopy: The bean-like interface to Jalopy. Sample Usage // create a new Jalopy instance with the currently active code convention settings Jalopy jalopy = new Jalopy(); File file = ...; // specify input and output target jalopy.setInput(file); jalopy.setOutput(file); // format and overwrite the given input file jalopy.format(); if (jalopy.getState() == Jalopy.State.OK) System.out.println(file + " successfully formatted"); else if (jalopy.getState() == Jalopy.State.WARN) System.out.println(file + " formatted with warnings"); else if (jalopy.getState() == Jalopy.State.ERROR) System.out.println(file + " could ...
• JavadocLexer: Token lexer for the Javadoc parser. This lexer has limited build-in error recovery which relies on the generated token types mapping table ( JavadocTokenTypes.txt ). Therefore it is a necessity to copy this file after every build into the directory where the classfile comes to reside. I strongly encourage you to automate this process as part of your Ant build script or whatever build tool you use. Sample Usage: // an input source Reader in = new BufferedReader(new FileReader(new File(argv[0]))); // create a lexer Lexer lexer = new JavadocLexer(); // set up the lexer to read from the input source ...
• ConventionKeys: Provides the valid keys for accessing the values in a code convention. Use this class in conjunction with ConventionDefaults to access the convention settings: Convention settings = Convention .getInstance(); int numThreads = settings.getInt( ConventionKeys .THREAD_COUNT, ConventionDefaults .THREAD_COUNT));
• ConventionDefaults: Holds the default code convention values (Sun Java Coding Style). Use this class in conjunction with ConventionKeys to access the convention settings: Convention settings = Convention .getInstance(); int numThreads = settings.getInt( ConventionKeys .THREAD_COUNT, ConventionDefaults .THREAD_COUNT));
• Convention: Represents a code convention: the settings that describe the desired coding style for Java source files. To ensure type-safety, valid key access, two accompanying classes are provided: Convention settings = Convention .getInstance(); int numThreads = settings.getInt( ConventionKeys .THREAD_COUNT, ConventionDefaults .THREAD_COUNT));
• ProgressPanel: A component that can be used to display progress information to the user. The panel displays the number of errors, warnings and processed files, along with a short text message and an optional progress bar. +---------------------------------------------------------------+ | Warnings: 2 Errors: 0 Files: 10 | | | | Processing ./src/java/de/hunsicker/jalopy/JalopyShell.java | | | | |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX | | +---------------------------------------------------------------+ The panel reflects the state of all logger channels as it increases its counters as warnings or errors ...
• SwitchPrinter: Printer for switch selection statements [ LITERAL_switch ]. switch ( integral-selector ) { case integral-value1 : statement // ... break; case integral-value2 : statement // ... break; case integral-value3 : statement // ... break; // ... default: statement } which translates to: LITERAL_switch + -- EXPR + ... + -- LCURLY + -- CASE_GROUP + -- LITERAL_case + -- EXPR + -- ... + -- SLIST + -- ... + -- CASE_GROUP + -- CASE_GROUP ... + -- RCURLY
• JavadocParser: Parser for Javadoc comments. Sample Usage: // an input source Reader in = new BufferedReader(new FileReader(new File(argv[0]))); // create a lexer Lexer lexer = new JavadocLexer(); // set up the lexer to read from the input source lexer.setInputBuffer(in); // get the corresponding parser Parser parser = lexer.getParser(); // and start the parsing process parser.parse(); This is an ANTLR automated generated file. DO NOT EDIT but rather change the associated grammar ( java.doc.g ) and rebuild.
• JavaLexer: Token lexer for the Java parser. Heavily based on the public domain grammar file written by Terence Parr et al. See http://www.antlr.org/resources.html for more info. Note that this parser relies on a patched version of ANTLR 2.7.2. It currently won't work with any other version. This is an ANTLR automated generated file. DO NOT EDIT but rather change the associated grammar ( java.g ) and rebuild.
• History: History serves as a tracker for file modifications. The flush() 55 method may be used to synchronously force updates to the backing store. Normal termination of the Java Virtual Machine will not result in the loss of pending updates - an explicit flushing is not required upon termination to ensure that pending updates are made persistent. This class is thread-safe.
• JavaParser: Parser for the Sun Java language. Heavily based on the public domain grammar written by Terence Parr et al. See http://www.antlr.org/resources.html for more info. This is an ANTLR automated generated file. DO NOT EDIT but rather change the associated grammar ( java.g ) and rebuild.
• SyntaxDocument: The interface a document must implement to be colorizable by the SyntaxEditorKit . It defines two methods, one that returns the TokenMarker that will split a line into a list of tokens, and a method that returns a color array that maps identification tags returned by the token marker into Color objects. The possible token identifiers are defined as static fields in the Token class.
• SettingsDialog: The Jalopy settings dialog provides a graphical user interface to manage, display and interactively test and edit the available code convention and asorted configuration settings. The dialog can be used from other Java applications as usual, in which case it acts like any other JDialog (i.e. as a secondary window). But it may be also invoked directly from the command line, magically serving as the main application window.
• FlowControlPrinter: Printer for flow control statements ( LITERAL_break and LITERAL_continue . label1: outer-iteration { inner-iteration { // ... break ; // ... continue ; // ... continue label1; // ... break label1; } }
• TokenMarker: A token marker that splits lines of text into tokens. Each token carries a length field and an indentification tag that can be mapped to a color for painting that token. For performance reasons, the linked list of tokens is reused after each line is tokenized. Therefore, the return value of markTokens should only be used for immediate painting. Notably, it cannot be cached.
• DeclarationType: Represents a method type to distinguish between ordinary method names and those which adhere to the Java Bean naming conventions. The default order for comparing is: ordinary Java method names, mutator, accessor/tester. This can be changed via setOrder(java.lang.String) 55 .
• MethodType: Represents a method type to distinguish between ordinary method names and those which adhere to the Java Bean naming conventions. The default order for comparing is: ordinary Java method names, mutator, accessor/tester. This can be changed via setOrder(java.lang.String) 55 .
• SyntaxEditorKit: An implementation of EditorKit used for syntax colorizing. It implements a view factory that maps elements to syntax colorizing views. This editor kit can be plugged into text components to give them colorization features. It can be used in other applications, not just jEdit. The syntax colorizing package doesn't depend on any jEdit classes.
• ConsolePlugin: The console Plug-in provides a powerful command line interface for the Jalopy engine. Refer to the online manual for the list of valid command line options. You can find the most recent version of the manual on the official Jalopy homepage: http://jalopy.sf.net/
• IfElsePrinter: Printer for if-else statements [ LITERAL_if , LITERAL_else ]. if ( Boolean-expression ) { statement } else if ( Boolean-expression ) { statement } else { statement }
• LoggerTransformation: Transformation which checks debug logging statements and adds an enclosing boolean expression if not yet present. The current implementation only works for the Jakarta Log4J logging toolkit and is somewhat weak in that every method call with a name of "debug" will be recognized as a logging call.
• AssignmentOperatorPrinter: Printer for assignment operators [ PLUS_ASSIGN , MINUS_ASSIGN , STAR_ASSIGN , DIV_ASSIGN , MOD_ASSIGN , BAND_ASSIGN , BOR_ASSIGN , BXOR_ASSIGN , SL_ASSIGN , SR_ASSIGN , BSR_ASSIGN ].
• Token: A linked list of tokens. Each token has three fields - a token identifier, which is a byte value that can be looked up in the array returned by SyntaxDocument.getColors() to get a color value, a length value which is the length of the token in the text, and a pointer to the next token in the list.
• KeywordMap: A KeywordMap is similar to a hashtable in that it maps keys to values. However, the `keys' are Swing segments. This allows lookups of text substrings without the overhead of creating a new string object. This class is used by CTokenMarker to map keywords to ids.
| Home | Contact Us | Privacy Policy | Terms of Service |