Traduzione da XML a SQL

Da Tesine Linguaggi e Traduttori.

L'obiettivo che questo progetto intende raggiungere è la realizzazione di un traduttore che consenta di popolare la base di dati di un sistema on line per la localizzazione di moduli software a partire da files XML utilizzati come formato di interscambio/backup dati e editing/visualizzazione offline della base dati stessa. In particolare l'obbiettivo principale dell'applicazione sviluppata dovrà essere quello di permettere la messa in opera del sistema di localizzazione online a partire da una base dati precedentemente elaborata e memorizzata sul file XML.
Dunque il progetto si è articolato nello sviluppo di un'applicazione in linguaggio Java che permettesse all'utente, tramite un'interfaccia grafica basata sulle librerie Swing, di richiamare un traduttore, sviluppato tramite i tools JFLEX e CUP, che a partire dal file XML generasse le opportune query SQL e le eseguisse automaticamente sul Database.

Definizione del formato del file XML

Il file XML in ingresso è un dialetto XML a tutti gli effetti, che quindi eredita dall'XML la struttura dei tag, degli attributi e dei commenti ed è descritto formalmente dal seguente file XML Schema:

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://sardfox.mozdev.org" elementFormDefault="qualified">
 <xs:element name="ditzionariu">
  <xs:complexType>
   <xs:sequence>
    <xs:element name="languages" maxOccurs="1" minOccurs="1">
     <xs:complexType>
      <xs:sequence>
     	<xs:element name="language" minOccurs="1" maxOccurs="unbounded">
     	 <xs:complexType>
     	  <xs:simpleContent>
     	   <xs:extension base="xs:string">
     	    <xs:attribute name="isocode" type="xs:string" use="required" />
     	    <xs:attribute name="enabled" type="xs:string" use="optional" default="on" />
     	    <xs:attribute name="position" type="xs:decimal" use="optional" default="0" />
     	   </xs:extension>
     	  </xs:simpleContent>
     	 </xs:complexType>
     	</xs:element>
      </xs:sequence>
     </xs:complexType>
    </xs:element>
    <xs:element name="parts_of_speech" maxOccurs="1" minOccurs="1">
     <xs:complexType>
      <xs:sequence>
       <xs:element name="part" maxOccurs="unbounded" minOccurs="1">
      	 <xs:complexType>
      	  <xs:simpleContent>
      	   <xs:extension base="xs:string">
     	    <xs:attribute name="id" type="xs:decimal" use="required" />
     	    <xs:attribute name="attribute" type="xs:string" use="optional" />
     	   </xs:extension>
     	  </xs:simpleContent>
     	 </xs:complexType>
       </xs:element>
      </xs:sequence>
     </xs:complexType>
    </xs:element>
    <xs:element name="statuses" maxOccurs="1" minOccurs="1">
     <xs:complexType>
      <xs:sequence>
       <xs:element name="status" maxOccurs="unbounded" minOccurs="1">
        <xs:complexType>
         <xs:simpleContent>
          <xs:extension base="xs:string">
     	    <xs:attribute name="id" type="xs:decimal" use="required" />
      	   </xs:extension>
     	  </xs:simpleContent>
     	 </xs:complexType>
       </xs:element>
      </xs:sequence>
     </xs:complexType>
    </xs:element>
    <xs:element name="users" maxOccurs="1" minOccurs="1">
     <xs:complexType>
      <xs:sequence>
       <xs:element name="user" maxOccurs="unbounded" minOccurs="1">
        <xs:complexType>
     	  <xs:simpleContent>
          <xs:extension base="xs:string">
     	    <xs:attribute name="id" type="xs:decimal" use="required" />
          </xs:extension>
         </xs:simpleContent>
        </xs:complexType>
       </xs:element>
      </xs:sequence>
     </xs:complexType>
    </xs:element>
    <xs:element name="word_list" maxOccurs="1" minOccurs="1">
     <xs:complexType>
      <xs:sequence>
       <xs:element name="word" maxOccurs="unbounded" minOccurs="0">
        <xs:complexType>
      	  <xs:sequence>
          <xs:element name="translation" maxOccurs="unbounded" minOccurs="0">
     	    <xs:complexType>
     	     <xs:simpleContent>
             <xs:extension base="xs:string">
              <xs:attribute name="id" type="xs:decimal" use="required" />
              <xs:attribute name="language" type="xs:string" use="required" />
              <xs:attribute name="infinite" type="xs:string" use="optional" />
              <xs:attribute name="plural" type="xs:string" use="optional" />
              <xs:attribute name="status" type="xs:string" use="optional" />
              <xs:attribute name="by" type="xs:string" use="optional" />
              <xs:attribute name="at" type="xs:string" use="optional" />
              <xs:attribute name="comment" type="xs:string" use="optional" />
             </xs:extension>
            </xs:simpleContent>
           </xs:complexType>
     	   </xs:element>
         </xs:sequence>
     	  <xs:attribute name="id" type="xs:decimal" use="required" />
     	  <xs:attribute name="value" type="xs:string" use="required" />
     	  <xs:attribute name="comment" type="xs:string" use="optional" />
     	  <xs:attribute name="type" type="xs:string" use="required" />
        </xs:complexType>
       </xs:element>
      </xs:sequence>
     </xs:complexType>
    </xs:element>
   </xs:sequence>
   <xs:attribute name="generated_at" type="xs:string" use="optional" />
   <xs:attribute name="generated_by" type="xs:string" use="optional" />
  </xs:complexType>
 </xs:element>
</xs:schema>

In sostanza il file è suddiviso, tramite opportuni tag, in delle sezioni contenenti le varie parti della base dati che si andrà a generare:

<languages>...</languages>

Sezione contenente l'elenco delle lingue, ognuna di esse definita da un tag <language>

<parts_of_speech>...</parts_of_speech>

Sezione contenente l'elenco delle categorie grammaticali, ognuna di esse definita da un tag <part>

<statuses>...</statuses>

Sezione contenente l'elenco dei possibili status che può assumere una traduzione (ad esempio confermata, aggiornata, etc.), ognuno di essi definita da un tag <status>

<users>...</users>

Sezione contenente l'elenco degli utenti che hanno inserito le traduzioni, ognuno di esse definito da un tag <user>

<word_list>...<word_list>

Sezione contenente l'elenco delle parole presenti nella base di dati, ognuna di esse definita da un tag <word>

<word>...<word>

Sezione contenente l'elenco delle traduzioni per la parola corrente, ognuna di esse definita da un tag <translation>

Ogni tag, inoltre, può possedere diversi attributi sia opzionali che obbligatori, illustrati nel dettaglio nel file XML Schema precedente. Un file XML di esempio contenente la basi di dati utilizzata per la localizzazione di Firefox in lingua sarda può essere scaricato all'indirizzo: http://sardfox.mozdev.org/installation.html?lang=sc E' inoltre da notare come tale file XML possa essere abbinato a un corrispondente foglio di stile XSL (esempio) per la visualizzazione delle informazioni contenute nel file.

Analisi Lessicale

L'analisi lessicale del file in ingresso è stata implementata tramite una scanner realizzato con il tool JFLEX. Esso si occupa sostanzialmente di riconoscere i tag e gli attributi noti e tradurli in simboli interpretabili dal parser (associando a ognuno di essi informazioni utili come per esempio il numero della riga dove è presente il simbolo che viene utilizzato nella gestione degli errori). Per individuare in maniera più precoce possibile eventuali errori sintattici, si è inoltre deciso di utilizzare una serie di stati che imponessero allo scanner di riconoscere di volta in volta solo il sottoinsieme di tag possibili nelle varie sezione del file in ingresso.
Tale meccanismo è stato adottato, anche se in maniere più elastica, anche per il riconoscimento degli attributi dei vari tag. In questo caso, per evitare la creazione di un numero eccessivo di stati, si è utilizzato uno stack per memorizzare la stato a cui tornare una volta terminata la lettura di un attributo.

E' da sottolineare che un tale approccio non consente di individuare tutti i possibili errori sintattici, che verranno gestiti dal parser, ma permette di segnalare prontamente all'utente gli errori più evidenti (come la presenza di tag errati all'interno delle sezioni).

Di particolare interesse è il riconoscimento dei valori (stringhe di caratteri qualsiasi) che potevano assumere i tag e gli attributi. Essi sono stati infatti definiti in base alla non comparsa del carattere di terminazione della stringa (> o < nel caso dei tag e " nel caso degli attributi) e sono stati implementati tramite le seguenti macro:

string = [^<>]*
stringatt = [^\u0022]*

Per quanto riguarda la gestione dei commenti (  ) e dei tag XML ( <?xml...?> ) sono stati creati degli stati appositi che permettono di non considerare il contenuto all'interno di tali tag in quanto non rilevanti per la generazione della base dati.

Infine è da segnalare l'inclusione all'interno del file sorgente JFLEX delle clausole %line, %cup, %standalone e %unicode nonchè delle direttiva import java_cup.runtime.*; e import java_cup.*; per il corretto accoppiamento con CUP; e della clausola %class ScannerDitzionariu e della direttiva package org.sardfox.parsditz.parser; per l'integrazione dello scanner all'interno dell'applicazione.

Analisi Sintattica

L'analisi sintattica del file XML è stata implementata tramite un parser sviluppato con il framework CUP. Esso riceve in input i simboli generati dallo scanner e si occupa di verificare che le regole sintattiche definite al suo interno siano rispettate, e in caso contrario genera dei warning o dei messaggi di errore verso l'interfaccia grafica.
Il parser si occupa inoltre di validare semanticamente il file e di generare le opportune azioni semantiche (vedi la sezione successiva).

L'analisi sintattica è stata definita in base a delle regole (produzioni) che rispecchiano grosso modo la suddivisione gerarchica del file in sezioni, tag e attributi. In particolare si sono adottati i simboli generati dal parser come terminali della grammatica, mentre si sono creati dei simboli non terminali per rappresentare le entità non atomiche (come le sezioni, le liste di tag o attributi, etc.).

Particolare attenzione si è anche prestata per il controllo e la gestione degli errori a livello sintattico. Infatti, tramite il simbolo terminale error si sono gestite tutte le regole sintattiche che potevano generare errori. Una volta generata l'eccezione sintattica il parser gestisce la situazione innanzitutto discriminando se si tratta di un errore irrecuperabile (per esempio manca qualche tag fondamentale, oppure non sono presenti delle sezioni obbligatorie) o con effetti limitati solo ad una singola produzione. Successivamente esso, tramite le classi di supporto, visualizza un'opportuna finestra di informazione per l'utente che permette eventualmente di decidere se terminare il parsing (ed esegure un rollback delle azioni semantiche precedentemente eseguite sul database) o di ignorare solamente i token errati e andare avanti nel parsing del file.

Di seguito è riportato un tipico esempio di gestione di errore sintattico recuperabile:

posattribute ::= [...]
              | error:er {: 
                 if(ditz.reportParseError("WRONG_POS_ATT", "" + (erleft+1), false))
                   RESULT = null;
                 else
                   throw new Exception("Wrong Part of Speech attribute at line " + (erleft+1));
              :};

Analisi Semantica

L'analisi semantica è stata implementata anch'essa tramite il parser. In questa fase si verifica la correttezza semantica del file in ingresso (per esempio se i valori assunti dagli attributi sono accettabili) e in caso affermativo si effettuano le opportune azioni semantiche per popolare la base di dati. Nel caso in cui, invece, venisse riscontratto un'errore, viene attivata la routine di gestione degli errori in maniera simile al caso degli errori sintattici.

Le azioni semantiche utilizzate si dividono in tre categorie principali:

Azioni per il popolamento delle Symbol Table;

Tali azioni semantiche vengono effettuate nelle sezioni iniziali del file e servono per memorizzare i simboli che verranno utilizzati nelle sezioni successive. Durante tali azioni si verifica sempre che il simbolo non sia duplicato e che sia valido, e successivamente esso viene memorizzato su un'opportuna HashMap.
Di seguito è riportato un tipico esempio di questo genere di azioni semantiche:

user ::= STARTUSER:su STARTID INTVALUE:id STOP ENDTAG VALUE:name STOPUSER {:
         if(!this.users.containsKey(name) && !this.users.containsValue(id)) {
             [...]
             this.users.put(name, id);
         }
         else if(!ditz.reportParseError("USER_DUPLICATED", "" + (suleft+1), false))
             throw new Exception("Duplicated User (" + name + ") at line " + (suleft+1));
         :}
         [...]

Azioni per la concatenazione di più attributi o tag;

Le azioni semantiche di questo tipo vengono utilizzate per unire degli attributi di una stesso tag, o dei tag di una stessa sezione, e sono utilizzate per la preparazione delle query. Infatti tali regole permettono di inserire in una lista i valori dei vari campi che successivamente verranno scritti sul database.
Di seguito è riportato un tipico esempio di questo genere di regole semantiche:

posattributes ::=  posattributes:al posattribute:att {:
                   RESULT = makeAttributes(al, att);
               :}
               | posattribute:att {:
                   RESULT = makeAttributes(null, att);
               :};

NOTA: la funzione makeAttributes definita all'interno del parser, serve ad inserire in una lista di attributi l'attributo corrente.

Azioni per la generazione e l'esecuzione di query SQL.

Queste regole semantiche consistono sostanzialmente nella generazione delle query SQL opportune (tramite delle classi di supporto) per la scrittura sul database delle entità (tag, sezioni, etc.) lette dal file in ingresso, previa verifica della correttezza semantica delle stesse. In particolare il parser si occupa di generare la query individuando le tabelle e i campi sui quali agire ed eventualmente settando gli attributi opzionali non presenti con i valori di default.
Di seguito è riportato un tipico esempio di questo di regola semantica di questo tipo:

pos ::= STARTPART:sp posattributes:al ENDTAG VALUE:pos STOPPART {: 
            if(al == null) {
                if(!ditz.reportParseError("POS_WITHOUT_ATT", "" + (spleft+1), false))
                    throw new Exception("Part of Speech (" + pos + ") without attributes at line " + (spleft+1));
            }
            else if(!al.containsKey("id")){
                if(!ditz.reportParseError("POS_WITHOUT_ID", "" + (spleft+1), false))
                    throw new Exception("Part of Speech without ID at line " + (spleft+1));
            }
            else {
                if(!this.pos.containsKey(pos) && !this.pos.containsValue(new POS(((Integer)al.get("id")).intValue(), "", false, false))) {
                boolean infinite = false, plural = false;  //valori di default
                if(al.get("plural") != null) plural = true;
                    if(al.get("infinite") != null) infinite = true;
                        ditz.writePOS(((Integer)al.get("id")).intValue(), pos);
                        this.pos.put(pos, new POS(((Integer)al.get("id")).intValue(), pos, plural, infinite));
                }
                else if(!ditz.reportParseError("POS_DUPLICATED", "" + (spleft+1), false))
                    throw new Exception("Duplicated Part of Speech (" + pos + ") at line " + (spleft+1));
            }
        :}

Classi di supporto

Come sottolineato nelle sezioni precedenti, per la realizzazione di questa applicazione, si sono utilizzate diverse classi di supporto per gestire le diverse funzionalità supplementari oltre che per implementare alcuni meccanismi utili al parser.
Di seguito verranno illustrate quelle più significative:

Classe `ParsDitz`

La classe ParsDitz è l'entry point del programma, in quanto contiene il metodo main. Essa si occupa di leggere gli eventuali parametri da linea di comando (eseguendo eventualmente le azioni opportune) e inizializzare le classi principali. Infine si occupa di lanciare l'interfaccia grafica.

package `org.sardfox.parsditz.parser`

All'interno del package org.sardfox.parsditz.parser sono state implementate tutte le classi utili per il processo di parsing vero e proprio, ed in particolare le classi POS e Translation utilizzate per incapsulare le informazioni relative rispettivamente alle parti grammaticali del discorso e alle traduzioni; e la classe ParserDitzionariu utilizzata per incapsulare tutte le funzioni implementate nelle varie classi dei diversi package richiamate dal parser generato dal CUP (ParserditzionariuCUP).

Scendendo più nel dettaglio le classi POS e Translation hanno un costruttore che serve per inizializzare i loro attributi interni e una serie di funzioni getter per il prelievo di tali valori.
La classe ParserDitzionariu, invece, viene passata come parametro al parser e wrappa i metodi presenti nelle classi Database e ParseDitzGUI che vengono invocati del parser. Tale classe si occupa inoltre di inizializzare e lanciare il parser e di effettuare il controllo sull'esito delle operazioni sul Database.

package `org.sardfox.parsditz.utils`

All'interno del package org.sardfox.parsditz.utils sono state implementate tutte le classi di utilità generale dell'applicazione. In particolare la classe fondamentale che è presente in questo package è Database.

Classe `Database`

La classe Database è la classe che permette di effettuare tutte le operazioni sul DB, offrendo un'interfaccia ad alto livello delle operazioni SQL realizzate tramite driver JDBC. Tale classe, infatti, si occupa di stabilire la connessione con il server del database, di eseguire l'esecuzione delle query, e di gestire gli eventuali errori ed eccezioni generate durante queste operazioni.

In particolare la classe espone i seguenti metodi pubblici:

public boolean connect(String server, String dbname, String user, String pwd, boolean generateErrors)

Tale funzione tenta di stabilire una connessione con i parametri specificati e restituisce l'esito dell'operazione. Se il flag generateErrors è vero viene visualizzata a scermo una finestra di errore.

public boolean isConnected()

Restituisce true se è attualmente attiva una connessione ad un database.

public boolean disconnect()

Tenda di chiudere la connessione al server e restituisce l'esito dell'operazione.

public void createdb(String server, String dbname, String user, String password)

Crea un nuovo database con la struttura base del db, sul server passato come parametro.

public boolean dbexist(String server, String dbname, String user, String password)

Restituisce vero se il database passato come parametro esiste ed è accessibile con le credenziali di autenticazione fornite.

public boolean writeLanguage(String isocode, String language, boolean enabled, int position)
public boolean writePOS(int id, String pos)
public boolean writeUser(int id, String user)
public boolean writeStatus(int id, String status)
public boolean writeWord(int id, String value, int posid, String comment)
public boolean writeTranslation(int wordid, int id, String languagecode, String translation, String infinite, String plural, int userid, long at, int status, String comment)

Tenta di inserire sul database una nuova entry nella tabella opportuna e con i parametri specificati. Restituisce true se l'operazione va a buon fine.

public void commit()

Esegue il commit sul database.

public void rollBack()

Esegue il rollback sul database.

package `org.sardfox.parsditz.gui`

All'interno del package org.sardfox.parsditz.gui sono presenti tutte le classi utili per la gestione dell'interfaccia grafica. In particolare, oltre alla classe principale ParsDitzGUI, sono presenti delle classi per la gestione degli eventi come la pressione dei pulsanti o l'attivazione di procedure.

Classe `ParsDitzGUI`

La classe ParsDitzGUI estende la classe JFrame e implementa la finestra principale dell'applicazione. Essa si occupa principalmente di visualizzare gli elementi grafici e di gestire i vari eventi generati da tali elementi. Di particolare interesse sono le funzionalità di gestione degli errori generati durante il processo di parsing o dal database e di internazionalizzazione che verranno illustrate nel dettaglio più avanti.

Nella sezione galleria immagini sono presenti alcune schermate dell'interfacci grafica realizzata.

Funzioni di gestione degli errori

Le funzioni di gestione degli errori si occupano di rendere visibile all'utente le anomalie riscontrate durante il funzionamento dell'applicazione permettono, in alcuni casi, di interagire con l'utente per il superamento dell'errore riscontrato.
Tali funzionalità sono implementate tramite i seguenti metodi della classe ParsDitzGUI:

public boolean reportParseError(String error, String param, boolean fatal)

Visualizza una finestra riportante il tipo di errore riscontrato e la linea in cui esso si è verificato. Se il flag fatal è settato a false, permette all'utente di stabilire se ignorare il token contenente l'errore oppure se terminare il parsing corrente realizzanto anche il rollback delle operazioni compiute sul database fino a quel momento.

public printError(String error, Exception ex, boolean fatal)

Visualizza una finestra riportante i dettagli di un'eccezione che si è generata durante l'esecuzione del programma (per esempio non se non è presente il driver del database oppure il file da utilizzare nel parsing non è valido) e se il flag fatal è verificato termina l'esecuzione del programma.

public void printWarning(String warning, String param, boolean abort)

Visualizza una finestra riportante i dettagli di una situazione anomala che si è verificata durante l'esecuzione del programma. Se il flag abort è verificato l'operazione corrente viene interrotta e viene restituito il controllo alla finestra principale.

public void printAction(String action, String param, int per)

Tale funzione è utilizzata per stampare dei messaggi di informazione all'utente (e dunque anche informazioni su degli errori) nella barra di stato. L'intero per, compreso tra 0 e 100, indica la percentuale di completamento dell'azione corrente.

Internazionalizzazione & Localizzazione

Nella realizzazione di un programma per la gestione di file di localizzazione si è prestata particolare attenzione agli aspetti dell'internazionalizzazione. A livello implementativo si è dunque deciso di esternalizzare tutte le stringhe presenti nell'interfaccia grafica in dei file presenti nella directory resources/languages e di caricarle al runtime in base alla lingua selezionata dall'utente.
Il nome di tali file di localizzazione è gui_CODE.properties dove code è il codice ISO della lingua selezionata, ed essi hanno una semplice struttura key = value facilmente localizzabili tramite strumenti informatici come Ditzionariu.
Tale funzionamento è implementato nella classe ParsDitzGUI dal metodo:

private void updateLanguage()

Questa funzione che si occupa di effettuare l'aggiornamento dell'interfaccia utente è, e dunque di tutte le stringhe in essa contenute, alla nuova lingua selezionata (memorizzata nel membro privato lang).

Web Application per traduzioni online: Ditzionariu

Come detto in introduzione, l'applicazione sviluppata ha come scopo principale quello di popolare una base di dati utilizzata successivamente come backend di un applicativo on line per la localizzazione di moduli software. In tale sezione quindi, presenteremmo brevemente le caratteristiche di tale software.

Si è deciso di sviluppare questa Web application su una piattaforma LAMP (cioè Linux, Apache, MySQL, PHP) e di utilizzare come livello di presentazione il software libero CMSKey per implementare tutte le funzionalità di presentazione, gestione utenti, internazzionalizzazione, etc.
In pratica si è deciso di concentrarsi principalmente sulla logica dell'applicazione fornendo le funzionalità utili ad un progetto di localizzazione.

In particolare, attualmente è disponibile e rilasciata una versione di tale prodotto che permette l'aggiunta di nuovi termini da tradurre, l'aggiunta di nuove traduzione con relativo status (confermata, aggiornata, etc.) assegnato ad ogni traduzione, e l'estrazione di informazioni statistiche da tale base dati. L'ultima versione stabile disponibile è presente all'indirizzo http://www.sardfox.org/ditzionariu
E' inoltre attualmente in fase di realizzazione una versione contenente il supporto multi-prodotto e multi-file, gestione avanzata degli utenti e dei task di amministrazione, rinnovata interfaccia grafica e produzione automatica dei file in uscita.

Nelle sezioni successive è disponibile una galleria di immagini della web application.

Manuale utente

In tale sezione si illustreranno brevemente i comandi dell'applicazione per il suo utilizzo dal punto di vista dell'utente:

Sezione Informazioni di connessione

Permette di inserire tutti i parametri di connessione dell'applicazione

Sezione Ditzionariu

Permette di selezionare il file di cui si vuole lanciare il parsing

Sezione Prodotto

Non ancora implementata (vedi la sezione Sviluppi futuri)

Pulsante Genera DB

Permette di creare sul database la struttura vuota della base di dati

Pulsante Invia Dati

Permette di effettuare il parsing del file in ingresso e di popolare il database.

Menu Lingua

Permette di selezionare la lingua di localizzazione dell'interfaccia grafica.

Parametri da linea di comando

L'applicazione può ricevere in ingresso alcuni parametri:

-h --help

Stampa una descrizione dei parametri dell'applicazione.

-v --version

Stampa una breve descrizione dell'applicativo, il suo numero di versione e una breve nota di copyright.

-l language --lang language

Permette di settare la lingua dell'applicazione al valore language.

Sviluppi futuri

L'applicazione attualmente è sostanzialmente terminata nelle sue parti fondamentali, anche se in futuro è possibile che vengano implementate alcune funzionalità opzionali per renderlo ulteriormente utile per la gestione della base di dati della web application.
In particolare gli aspetti che saranno sviluppati a breve sono:

Gestione dei prodotti e parsing dei principali formati file di localizzazione (PROPERTIES, DTD, PO, etc.);

Realizzazione di un manuale utente;

Localizzazione in ulteriori lingue;

Memorizzazione delle impostazioni (lingua preferita, dati di connessione, etc.) in un file di configurazione;

Realizzazione della documentazione JavaDoc delle classi realizzate;

Realizzazione di un file Ant per il building automatico dell'applicazione;

Pacchettizzazione nel formato "eseguibile" jar.

E' possibile scaricare la versione più aggiornata del codice dell'applicazione dal repository CVS di SardFox.

Note di Compilazione

Per la compilazione del progetto è necessario avere a disposizione la piattaforma JAVA SE 1.5 o successive e i tool CUP v0.11a beta 20060102 e JFlex v. 1.4.1.
Per il corretto funzionamento al runtime è inoltre necessario aver inserito nel classpath JAVA il percorso del driver JDBC per MySQL e delle librerie di CUP e avere a disposizione delle credenziali di accesso per un server MySQL.

In generale è consigliabile utilizzare l'ambiente di sviluppo Eclipse per la compilazione del progetto (di cui vengono forniti i files .classpath e .project).

Se si preferisce la compilazione manuale, si dovranno innanzitutto generare le classi del parser (ParserditzionariuCUP.java e ParserditzionariuSym.java) e dello scanner (ScannerDitzionariu.java) all'interno del package org.sardfox.parsditz.parser.
Successivamente si dovranno compilare tutte le classi presenti nei diversi package (org.sardfox.parsditz.*).
Infine si dovrà copiare la cartella src/resources in bin/resources

Sostanzialmente, da console, una volta selezionata la cartella principale del programma si dovranno dare i seguenti comandi:

jflex src/org/sardfox/parsditz/parser/scannerditzionariu.jflex

cup -package org.sardfox.parsditz.parser -parser ParserditzionariuCUP -symbols ParserditzionariuSym src/org/sardfox/parsditz/parser/parserditzionariu.cup

javac -sourcepath src -classpath bin -d bin/org/sardfox/parsditz/[package] src/org/sardfox/parsditz/[package]/[nomeclasse.java]

cp -a src/resources bin/resources

Per lanciare l'esecuzione del programma, una volta che ci si è assicurati di avere nel classpath tutte le librerie necessarie (vedi istruzioni), dalla directory bin/ si lancia il seguente comando

java org.sardfox.parsditz.ParsDitz [parametri]

Per i valori possibili dei parametri vedi la sezione Parametri da linea di comando.

NOTA: è in programma la realizzazione di un file Ant per il building automatico dell'applicazione.

Risorse

[Pacchetto .tar.gz completo]

Il pacchetto contiene, nella cartella src la seguente struttura delle directory/file:

-- src
   |-- org
   |   `-- sardfox
   |       `-- parsditz
   |           |-- ParsDitz.java
   |           |-- gui
   |           |   |-- BrowserLaunch.java
   |           |   |-- GenerateDB.java
   |           |   |-- ParsDitzAction.java
   |           |   `-- ParsDitzGUI.java
   |           |-- parser
   |           |   |-- POS.java
   |           |   |-- ParserDitzionariu.java
   |           |   |-- ParserditzionariuCup.java
   |           |   |-- ParserditzionariuSym.java
   |           |   |-- ScannerDitzionariu.java
   |           |   |-- Translation.java
   |           |   |-- parserditzionariu.cup
   |           |   `-- scannerditzionariu.jflex
   |           `-- util
   |               |-- Database.java
   |               `-- FileDitzionariu.java
   `-- resources
       |-- example files
       |   |-- ditzionariu with some comments.xml
       |   |-- ditzionariu with some duplicated entries.xml
       |   |-- ditzionariu without optional attributes.xml
       |   |-- ditzionariu without some required attributes.xml
       |   |-- ditzionariu without translations.xml
       |   |-- ditzionariu without words.xml
       |   |-- ditzionariu.xml
       |   `-- ditzionariu_files
       |       |-- ditzionariu.css
       |       |-- ditzionariu.xsl
       |       |-- gnu-fdl.png
       |       |-- gnu-gpl.png
       |       `-- schemaditzionariu.xsd
       |-- images
       |   `-- logo.png
       |-- languages
       |   |-- gui.properties
       |   |-- gui_it.properties
       |   `-- gui_sc.properties
       |-- licenses
       |   `-- GPL v.3 license.txt
       `-- sql
           `-- newDB.sql

Oltre alle cartelle dei package illustrati in precedenza è presente la directory resources che contiene tutte le risorse necessarie al funzionamento del programma (i file di localizzazione, le immagini, la struttura del database in SQL) e dei file aggiuntivi (licenza, files di esempio).

Galleria Immagini

ParsDitz

Interfaccia di ParsDitz
(italiano)

Interfaccia di ParsDitz
(inglese)

Messaggio di errore
DB esistente

Messaggio di errore
durante il parsing

Ditzionariu

Ditzionariu:
vista generale

Ditzionariu:
aggiunta traduzione

Ditzionariu:
modifica traduzione

Link esterni

SardFox
SardFox Mailing List
SardFox CVS Repository (Web version)
Bug Tracking (Segnala bug)
Ditzionariu

Jflex
CUP
Sun Java 6
Eclipse
CMSKey
MySQL
Apache
PHP

Ringraziamenti

Ringrazio tutto il team di SardFox per il lavoro di testing dell'applicazione e di segnalazione di bug.

Note di Copyright

La presente documentazione è rilasciata sotto la licenza GNU Free Documentation License 1.2

Salvo dove differentemente specificato:

ParsDitz è rilasciato sotto la licenza GNU GPL 3.
Ditzionariu è rilasciato sotto la licenza GNU GPL 2.

Ricavato da "http://www.skenz.it/traduttori/tesine/index.php?title=Traduzione_da_XML_a_SQL"

Traduzione da XML a SQL

Da Tesine Linguaggi e Traduttori.

Contents

Definizione del formato del file XML

Analisi Lessicale

Analisi Sintattica

Analisi Semantica

Classi di supporto

Classe `ParsDitz`

package `org.sardfox.parsditz.parser`

package `org.sardfox.parsditz.utils`

Classe `Database`

package `org.sardfox.parsditz.gui`

Classe `ParsDitzGUI`

Funzioni di gestione degli errori

Internazionalizzazione & Localizzazione

Web Application per traduzioni online: Ditzionariu

Manuale utente

Parametri da linea di comando

Sviluppi futuri

Note di Compilazione

Risorse

Galleria Immagini

Link esterni

Ringraziamenti

Note di Copyright

Views

Personal tools

Navigation

Cerca

Toolbox

Traduzione da XML a SQL

Da Tesine Linguaggi e Traduttori.

Contents

Definizione del formato del file XML

Analisi Lessicale

Analisi Sintattica

Analisi Semantica

Classi di supporto

Classe ParsDitz

package org.sardfox.parsditz.parser

package org.sardfox.parsditz.utils

Classe Database

package org.sardfox.parsditz.gui

Classe ParsDitzGUI

Funzioni di gestione degli errori

Internazionalizzazione & Localizzazione

Web Application per traduzioni online: Ditzionariu

Manuale utente

Parametri da linea di comando

Sviluppi futuri

Note di Compilazione

Risorse

Galleria Immagini

Link esterni

Ringraziamenti

Note di Copyright

Views

Personal tools

Navigation

Cerca

Toolbox

Classe `ParsDitz`

package `org.sardfox.parsditz.parser`

package `org.sardfox.parsditz.utils`

Classe `Database`

package `org.sardfox.parsditz.gui`

Classe `ParsDitzGUI`