Linguaggi / Java

JCH - Javac Compiler Helper

Abstract
Javac Compiler Helper, in breve jch, è un wrapper per il compilatore standard java (javac), che aumenta le caratteristiche di default del compilatore base.

Data di stesura: 07/07/2004
Data di pubblicazione: 12/07/2004
Ultima modifica: 04/04/2006

di Donato Ferrante

Contenuti

Introduzione
Cosa fa Jch
Come usare Jch
Il database: tree.jch
Conclusioni

Introduzione

Javac Compiler Helper, in breve jch, è un wrapper per il compilatore standard java (javac), che aumenta le caratteristiche di default del compilatore base.

Jch è un programma da me scritto, ed al momento della stesura di questo articolo è giunto alla versione 0.2.2.

Cosa fa Jch

Jch permette ai programmatori Java di ignorare, al momento della scrittura del codice sorgente di un qualsivoglia programma, le noiose procedure di import.

Infatti capita spesso di dover cercare la classe necessaria, al funzionamento del codice, nella documentazione java oppure per evitare ciò, si tende ad importare interi package. Quest'ultima cosa è sconsigliata dal momento che il programma ne risentirà in termini di prestazioni.

Vediamo un esempio, supponiamo di avere il seguente programma (Prova.java):

Prova.java

```
public class Prova { 
```
```
 
```

  public static void main(String [] args){

```
   
```
```
    // inutile ai fini del programma 
```
```
    InputStream in = null;  
```
```
     
```
```
    Vector v = new Vector(); 
```
```
     
```
```
    v.add("ciao "); 
```
```
    v.add("a "); 
```
```
    v.add("tutti!"); 
```
```
     
```
```
    Iterator itr = v.iterator(); 
```
```
 
```
```
    while(itr.hasNext()) 
```
```
      System.out.print(itr.next()); 
```
```
 
```
```
  } 
```
```
} 
```

Le classi presenti nel programma sono:

InputStream
Vector
Iterator

A questo punto si aprono due vie.

1. Importare gli interi package a cui appartengono le classi sopra, usando:

```
import java.io.*; 
```
```
import java.util.*; 
```

2. Importare le singole classi, ovvero:

```
import java.io.InputStream; 
```
```
import java.util.Vector; 
```
```
import java.util.Iterator; 
```

La vera difficoltà sorge quando il sorgente che si stà scrivendo contiene un grosso numero di classi eterogenee, il che conduce la maggior parte dei programmatori Java a seguire la prima via.

Ecco a questo punto, venire incontro ai programmatori, jch che seleziona accuratamente la classe maggiormente adatta agli intenti del programmatore e la importa singolarmente.

Come usare Jch

Una volta compilato ed installato jch, digitando jch da console otterremo una schermata che ci mostrerà quanto segue:

##############################################
#                   jch
#           Javac Compiler Helper
#
# version: 0.2.2
# coded by: Donato Ferrante
# e-mail: fdonato@autistici.org
# website: www.autistici.org/fdonato
##############################################
Usage: jch <options> <source file>
where possible options include:
  -g                        Generate all debugging info
  -g:none                   Generate no debugging info
  -g:{lines,vars,source}    Generate only some debugging info
  -nowarn                   Generate no warnings
  -verbose                  Output messages about what the compiler is doing
  -deprecation              Output source locations where deprecated APIs are used
  -classpath <path>         Specify where to find user class files
  -sourcepath <path>        Specify where to find input source files
  -bootclasspath <path>     Override location of bootstrap class files
  -extdirs <dirs>           Override location of installed extensions
  -d <directory>            Specify where to place generated class files
  -encoding <encoding>      Specify character encoding used by source files
  -source <release>         Provide source compatibility with specified release
  -target <release>         Generate class files for specific VM version
  -help                     Print a synopsis of standard options
  -k <p_name>               Get only class of p_name package
  -x <p_name>               Get only class not in p_name package
  -p                        Enable to use classes with priority in conf/tree.jch

Notiamo subito le nuove opzioni (rispetto a javac) messe a disposizione da jch:

-k <p_name>
-x <p_name>
-p

Esaminiamole da vicino.

-k <p_name>: permette di forzare jch a cercare esclusivamente, le classi necessarie, tra quelle presenti in un determinato package (p_name).

-x <p_name>: permette di forzare Jch a cercare le classi necessarie, ignorando quelle presenti in un determinato package (p_name).

-p: abilita Jch a cercare le classi necessarie prima tra quelle con priorità maggiore (in conf/tree.jch) dopodichè tra le restanti.

Ovviamente con jch è possibile utilizzare tutte le opzioni standard messe a disposizione dal compilatore javac standard.

Vediamo ora jch in azione. Ad esempio compiliamo il programma Prova.java con il comando, jch Prova.java:

##############################################
#                   jch
#           Javac Compiler Helper
#
# version: 0.2.2
# coded by: Donato Ferrante
# e-mail: fdonato@autistici.org
# website: www.autistici.org/fdonato
##############################################

##############################################

#               Javac Section:               #

##############################################


Prova.java:6: cannot resolve symbol
symbol  : class InputStream
location: class Prova
           InputStream in = null;
           ^
Prova.java:8: cannot resolve symbol
symbol  : class Vector
location: class Prova
           Vector v = new Vector();
           ^
Prova.java:8: cannot resolve symbol
symbol  : class Vector
location: class Prova
           Vector v = new Vector();
                          ^
Prova.java:14: cannot resolve symbol
symbol  : class Iterator
location: class Prova
           Iterator itr = v.iterator();
           ^
4 errors


##############################################

#       Javac Compiler Helper Section:       #

##############################################


Class Not Found: InputStream
Class Not Found: Iterator
Class Not Found: Vector

3 errors


Class Error: java.util.Vector -> [Fixed]
Class Error: java.util.Iterator -> [Fixed]
Class Error: java.io.InputStream -> [Fixed]

3 errors fixed

ed il nostro sorgente iniziale, senza alcun import, verrà modificato come segue:

```
import java.util.Vector; 
```
```
import java.util.Iterator; 
```
```
import java.io.InputStream; 
```
```
 
```
```
public class Prova { 
```
```
 
```

  public static void main(String [] args){

```
 
```
```
    // inutile ai fini del programma 
```
```
    InputStream in = null; 
```
```
 
```
```
    Vector v = new Vector(); 
```
```
 
```
```
    v.add("ciao "); 
```
```
    v.add("a "); 
```
```
    v.add("tutti!"); 
```
```
 
```
```
    Iterator itr = v.iterator(); 
```
```
 
```
```
    while(itr.hasNext()) 
```
```
      System.out.print(itr.next()); 
```
```
 
```
```
  } 
```
```
} 
```

Perfettamente compilabile e senza più errori di classe. A questo punto per effettuare la compilazione vera e propria basterà ridigitare: jch Prova.java e premere invio. Fatto ciò avremo il nostro programma pronto per essere eseguito.

Il database: tree.jch

Jch ha al suo interno un database al quale fa riferimento per poter lavorare correttamente.

Ecco come si presenta il database:

/*
 * Tree.jch
 * ( jch's database )
 *
 * powered by: Donato Ferrante
 * email: fdonato@autistici.org
 * website: www.autistici.org/fdonato
 *
 */



# PRI Classes - Section
# ( Use option -p, to enable this section )
#
# Below you can set your classes to have priority on NOP Classes







# NOP Classes - Section
#
# This section contains:
#
# 1. Java Standard Classes
# 2. Your new classes without priority.
#
# [ NOT MODIFY THE LINE BELOW! ]
#!


interface java.io.DataInput
interface java.io.DataOutput
interface java.io.Externalizable
interface java.io.FileFilter

(...)

Il database come è facile notare è suddiviso in due "blocchi":

1. PRI Classes

contiene le classi che hanno priorità sulle altre (blocco NOP), questo blocco viene attivato passando a jch l'opzione -p.

2. NOP Classes

contiene le classi standard java e le altre eventuali nuove classi importate dall'utente di jch.

Ogni blocco al suo interno ha un organizzazione piramidale. La classe al posto più alto nel blocco ha priorità sulle classi ad esso sottostanti. È da notare che il discorso è valido solo all'interno dei singoli blocchi: PRI e NOP.

Con la versione 0.2.2 di Jch è stato introdotta l'utility JchTree, la quale permette di aggiornare il database tree.jch a partire da un Java Package Tree (tipo http://java.sun.com/j2se/1.4.2/docs/api/java/net/package-tree.html).
Infatti dando in input a JchTree un file dal contenuto simile al seguente:

class java.net.DatagramSocket
  class java.net.MulticastSocket
class java.net.DatagramSocketImpl (implements java.net.SocketOptions)
class java.net.InetAddress (implements java.io.Serializable)
  class java.net.Inet4Address
  class java.net.Inet6Address
class java.net.NetworkInterface
class java.net.PasswordAuthentication
class java.security.Permission (implements java.security.Guard, java.io.Serializable)
  class java.security.BasicPermission (implements java.io.Serializable)
    class java.net.NetPermission
  class java.net.SocketPermission (implements java.io.Serializable)
class java.net.ServerSocket
class java.net.Socket
class java.net.SocketAddress (implements java.io.Serializable)
  class java.net.InetSocketAddress
class java.net.SocketImpl (implements java.net.SocketOptions)
class java.lang.Throwable (implements java.io.Serializable)
  class java.lang.Exception
    class java.io.IOException
      class java.io.InterruptedIOException
        class java.net.SocketTimeoutException
      class java.net.MalformedURLException
      class java.net.ProtocolException
      class java.net.SocketException
        class java.net.BindException
        class java.net.ConnectException
        class java.net.NoRouteToHostException
        class java.net.PortUnreachableException
      class java.net.UnknownHostException
      class java.net.UnknownServiceException

otterremo in output un nuovo file che conterrà le classi pronte per essere inserite nel database. (Per maggiori informazioni in merito vi rimando al README della relativa utility).

Conclusioni

A questo punto dopo averne descritto le caratteristiche non mi resta che augurarvi una buona compilazione con Jch.

Informazioni sull'autore

Donato Ferrante, classe 84. Programmatore e bug-researcher. Il suo sito web è: http://www.autistici.org/fdonato/

È possibile consultare l'elenco degli articoli scritti da Donato Ferrante.

Altri articoli sul tema Linguaggi / Java.

Risorse

Sito ufficiale.
http://www.autistici.org/fdonato/source.html#source_coding
Pagina del progetto su Freshmeat.net.
http://freshmeat.net/projects/jch
Copia disponibile sul sito dell'autore.
http://www.autistici.org/fdonato/articles/Javac_Compiler_Helper_ita.txt