BR Ufficio/KOffice/KFormula

Risoluzione dei problemi

Uno dei problemi più comuni che si verificano quando si installa KFormula sul proprio computer desktop é l'errore dovuto alla non corretta visualizzazione dei simboli matematici nell'editor.Questo é dovuto al fatto che con il programma vengono installati dei nuovi font che non vengono riconosciuti dal sistema.BR BR Puo capitare infatti che all'avvio del programma compaiano questi messaggi:"Potrebbe non essere avviato il processo.Impossibile creare un io-slave:Klauncher ha riscontrato un protocollo 'fonts' sconosciuto" e "Sono stati installati dei caratteri per assicurare che i simboli delle formule siano visualizzati correttamente.Devi riavviare l'applicazione per rendere effettive le modifiche".BR BR Per risolvere il problema é necessario eseguire quanto segue:BR BR 1. Spostarsi nella cartella di installazione delle font di KFormula:

cd /usr/share/apps/kformula/fonts

2. Copiare le font nella cartella di sistema:

sudo cp *.ttf /usr/share/fonts/truetype/

In questo modo i simboli matematici verranno visualizzati correttamente e non appariranno più messaggi di errore.

ATTENZIONE: QUESTA GUIDA È IN COSTRUZIONEBR

ink

ink è uno strumento per il rilevamento delle percentuali di inchiostro nelle cartucce delle stampanti che fa uso della libreria libinklevel.BR Il programma viene eseguito a riga di comando, perciò non è dotato di interfaccia grafica. Di seguito viene riportata la sintassi necessaria al suo utilizzo.BR

Innanzitutto, abilitare il [:Repository/Componenti:componente] universe dei [:Repository:repository] ufficiali e installare il pacchetto ink.

L'applicazione richiede i [:AmministrazioneSistema/Sudo:privilegi di amministrazione] per poter accedere in lettura e scrittura al dispositivo al quale la stampante viene collegata. Aprire un terminale e digitare:

sudo ink -p <nome_porta> [-n <numero_porta>]

dove <nome_porta> dev'essere sostituito dalla dicitura parport o usb a seconda del dispositivo usato e <numero_porta> deve corrispondere al numero della porta al quale la stampante è connessa.

Immagine(Icone/Piccole/note.png,,center)

Le parentesi quadre stanno a significare che l'argomento è opzionale e se non è specificato si assume che il numero della porta abbia valore 0.

Il risultato dovrebbe essere simile a questo:

ink v0.4.1 � 2007 Markus Heinz

EPSON Stylus DX4000

Cyan:                          53%
Yellow:                        48%
Magenta:                       55%
Photoblack:                   100%

Se al primo tentativo dovesse apparire un messaggio di errore come questo:

ink v0.4.1 � 2007 Markus Heinz

Unknown IEEE 1284.4 error number 66
Could not read from printer.
Could not get ink level.

provare a ripetere nuovamente il comando.BR

Si può anche usare un comando alternativo per quanto riguarda i dispositivi usb:

sudo ink -d /dev/usb/lp0

Nel caso specifico di una stampante di rete Canon BJNP è sufficiente dare il comando:

sudo ink -p bjnp

e per la stessa stampante è anche possibile specificare direttamente il suo indirizzo URI o IP in questo modo:

sudo ink -b bjnp://<indirizzo_URI_o_IP>

facendo ovviamente le dovute sostituzioni.BR BR Infine, per ottenere informazioni sulle versioni di ink e libinklevel utilizzate basta dare:

ink -v

escputil

Per utilizzare questo tool dedicato espressamente alle stampanti Epson consultare [http://wiki.ubuntu-it.org/Hardware/StampantiScanner/EpsonTools questa guida].

Ulteriori risorse

[http://libinklevel.sourceforge.net/ Pagina che fa riferimento alla libreria libinklevel su Sourceforge]

Il comando ignore viene solitamente utilizzato in ambito IRC quando, essendo abituali frequentatori di un canale non moderato e a causa dell'assenza di operatori che possano garantire un controllo nel canale, si renda necessario attuare una forma di difesa nei confronti di troll e provocatori vari che affollano comunemente le stanze di una chat, dei quali si vogliano ignorare i messaggi. Soluzione che di fatto scoraggia quest'ultimi dal postare messaggi indesiderati e li priva a priori della loro fonte di divertimento.BR

Immagine(Icone/Piccole/warning.png,,center)

Sarebbe preferibile non «abusare» della funzione 'ignore', e adoperarla solo se veramente necessario.

Per prima cosa serve registrare un nick sul server al quale si vuole accedere, in modo da poter essere riconosciuti e preservare la propria identità innanzitutto. Ad ogni accesso al server sarà quindi necessario identificarsi. Per far sì che l'identificazione avvenga in automatico ogni volta che si vuole accedere senza dover ripetere sempre il comando di identificazione occorrerà agire sulla configurazione del server che si può modificare attraverso le impostazioni del client.BR BR Se per esempio si utilizza XChat sarà sufficiente entrare in Lista Reti, selezionare il nome del server desiderato e scegliere Modifica->Password del Server inserendo nel campo vuoto la password scelta al momento della registrazione del nick.BR

Una volta eseguite queste operazioni preliminari, si può procedere a digitare il comando necessario per ignorare in effetti un utente indesiderato. Una volta entrati nel canale ed individuata la presenza della persona in questione, posizionarsi nel campo log e servirsi della seguente sintassi:

/ignore <maschera> <tipi..> [<opzioni..>]

Immagine(Icone/Piccole/note.png,,center)

Le parentesi quadre stanno a significare che l'uso di tali opzioni è facoltativo.

Per far si che il comando funzioni, si deve specificare al posto di <maschera> il nome della maschera corrispondente all'host dell'utente che si vuole ignorare. Per recuperare questo dato posizionarsi nel campo log e digitare:

/whois <nick>

dove al posto di <nick> si dovrà digitare il nick dell'utente in questione.BR A questo punto nella finestra principale del server appariranno alcune informazioni sull'utente. Di queste copiare soltanto la prima riga che dovrebbe essere del tipo:

nick!ident@host

anche se spesso può capitare che la parte relativa a nick! non sia presente all'interno della maschera.BR Quando questa stringa verrà copiata all'interno del comando ignore ricordarsi di eliminare un eventuale riferimento «mailto:» dalla maschera.BR

Per essere sicuri che l'ignore abbia effetto in quasi tutte le situazioni, si consiglia di sostituire la parte relativa a:

nick!

con

*!

anche se non presente.BR

Per quanto riguarda l'uso dei tipi ci si riferisce al tipo di dati da ignorare, le opzioni invece si possono omettere. Possono essere utili a riguardo queste due tabelle riassuntive:

Tipi
PRIV	consente di ignorare i messaggi privati in query
NOTI	ignora eventuali avvisi
CHAN	permette di ignorare i normali messaggi in canale
CTCP	ignora i messaggi CTCP
DCC	ignora i messaggi DCC
INVI	si riferisce alla possibilità di ignorare gli inviti in canale
ALL	include tutti i tipi di dato riportati sopra in una sola volta

Opzioni
NOSAVE	non conserva gli effetti dell'ignore anche per i successivi accessi al server
QUIET	non visualizza i messaggi relativi a comandi ignore nella finestra corrente

Immagine(Icone/Piccole/note.png,,center)

È possibile l'uso di due o più parametri contemporaneamente nel comando. Inoltre si può sempre cancellare un utente dalla lista 'ignore' attraverso l'utilizzo del comando «unignore», similmente a quanto fatto prima.

Se per esempio si volesse ignorare solo i messaggi privati e gli avvisi provenienti da un utente si dovrebbe digitare una cosa del genere:

/ignore *!tizio@host_qualunque.org PRIV NOTI

Programmazione/GdbBR

Introduzione

GNU Debugger (GDB) è un'applicazione di debugging, cioè uno strumento che consente di controllare un programma in esecuzione per scovare e rimuovere bug. GDB può analizzare programmi scritti in diversi linguaggi. In questa guida verrà spiegato come eseguire il debugging di un programma scritto in C, ma la procedura è analoga anche in altri casi. Inoltre verrà mostrata la procedura per realizzare un backtrace, sempre facendo uso di GDB, utile nella segnalazione dei bug dei programmi in Launchpad.

Preparativi

GDB è preinstallato in modo predefinito in Ubuntu. Prima di avviare l'applicazione è necessario compilare in modo speciale il file sorgente che si vuole analizzare:

gcc -ggdb prova.c -o prova

se per esempio il file sorgente è stato chiamato prova.c.BR Con il comando precedente il programma è stato compilato in modo da poter lavorare con GDB sull'eseguibile appena creato.

Utilizzare GDB

Per avviare il debugger basta aprire un terminale e dare:

gdb

L'interfaccia utente che verrà mostrata dal terminale è questa:

GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-linux-gnu".
(gdb)

Ora si deve specificare a GDB l'eseguibile su cui lavorare:
```
file prova
```
sempre riprendendo l'esempio precedente.BR Se tutto va bene verrà restituito un messaggio del genere:
```
Reading symbols from /home/.../prova...done.
```
A questo punto occorre impostare gli eventuali argomenti che di solito vengono passati al programma da analizzare quando lo si esegue. Se ad esempio per eseguire il programma si usa:
```
./prova arg1 arg2 arg3
```
con arg1, arg2 e arg3 argomenti del programma, in GDB si dovrà digitare:
```
set args arg1 arg2 arg3
```
Se invece non vengono usati argomenti è sufficiente digitare:
```
set args
```
Adesso è indispensabile comunicare al debugger almeno un breakpoint, cioè una riga di codice o una funzione nei pressi della quale fermare l'esecuzione del programma.
In questo modo, una volta interrotta l'esecuzione del programma, sarà possibile eseguirlo riga per riga.BR
Per inserire un breakpoint in corrispondenza della funzione main basta digitare:
```
break main
```
Se invece lo si vuole mettere ad una riga ben precisa, si usa la seguente sintassi:
```
break <numero_riga>
```
dove a <numero_riga> ovviamente va sostituito il numero di riga corrispondente al punto dove si vuole mettere il breakpoint.BR
Se il programma è composto da diversi file compilati insieme, occorre specificare anche il nome del file a cui appartiene la riga destinataria del breakpoint. Si fa ciò semplicemente separando il nome del file dal numero di riga attraverso l'uso dei due punti (:). Qui un esempio:
```
break prova_1.c:<numero_riga>
```
in cui prova_1.c è uno dei file facenti parte del programma.BR

Immagine(Icone/Piccole/note.png,,center)

Si possono specificare tanti breakpoint quanti se ne desidera.

Se tutto va bene dovrebbe apparire sullo schermo un messaggio del tipo:
```
Breakpoint 1 at 0x8048365: file prova_1.c, line 5.
```
Il numero che segue la parola Breakpoint (in questo caso 1) identifica in maniera univoca il breakpoint nel programma. Per rimuovere un breakpoint basta digitare:
```
delete break <numero_breakpoint>
```
dove al posto di <numero_breakpoint> occorre inserire il numero di breakpoint precedentemente assegnato.
Da questo momento in poi è possibile iniziare l'esecuzione vera e propria del programma. Per farlo basta utilizzare il seguente comando:
```
run
```
Così il debugger eseguirà il programma dalla prima riga in poi, fermandosi al primo breakpoint che incontra.BR Come prima, se il programma riceve argomenti dalla riga di comando, è necessario specificarli:
```
run arg1 arg2 arg3
```
riprendendo in questo caso l'esempio di prima.
A questo punto si è fermi ad un breakpoint. Il debugger mostra una riga di codice, la quale non è stata ancora eseguita. Tuttavia si possono eseguire alcune operazioni. Per stampare sullo schermo il valore di una variabile digitare:
```
print <nome_var>
```
oppure:
```
p <nome_var>
```
dove <nome_var> dev'essere sostituito con il nome corrispondente della variabile da visualizzare.BR Per vedere invece una porzione di codice prima e dopo quella in cui ci si trova attualmemte dare:
```
list
```
oppure:
```
l
```
In alternativa è possibile impostare a mano il valore di una variabile:
```
set var <nome_var>=<valore>
```
specificando il nome della variabile e un valore da assegnare al posto della stringa <valore>.
Si può andare avanti spostandosi alla riga di codice successiva digitando:
```
next
```
oppure:
```
n
```
Questo comando permette di saltare alla riga successiva della porzione di codice che si sta analizzando. Se la riga in cui ci si trova attualmente è la chiamata ad una funzione, con next non si entra dentro la funzione ma si passa direttamente alla riga elaborata dopo la sua esecuzione.BR Se invece si volesse entrare all'interno della funzione basterà digitare:
```
step
```
oppure:
```
s
```
Se si desidera mostrare costantemente sullo schermo il valore di alcune variabili basta ripetere questo comando per ogni variabile:
```
display <nome_var>
```
sostituendo come sempre a <nome_var> il nome della variabile da visualizzare.BR Il risultato sarà una riga del genere:
```
1: <nome_var> = -1208249712
```
dove il numero che precede i due punti (:) è l'identificativo di visualizzazione.BR
Per rimuovere la variabile dalla visualizzazione costante è sufficiente utilizzare il comando delete:
```
delete disp <numero_id>
```
dove <numero_id> è l'identificatore della variabile visualizzata.BR Qualora si voglia invece che il programma continui a lavorare fino al breakpoint successivo, digitare:
```
continue
```
oppure:
```
c
```
Infine, per uscire dal debugger, digitare:
```
quit
```
oppure:
```
q
```

Se si vogliono avere maggiori informazioni su un determinato comando si può usare l'istruzione:

help <nome_comando>

sostituendo <nome_comando> con il nome del comando a riguardo del quale si desidera ottenere ulteriori informazioni.

Ulteriori risorse

[http://www.gnu.org/software/gdb/ Pagina ufficiale del debugger GNU]
[http://www.topolinux.org/ezine_articles.php?art_id=39 Documento originale da cui è tratta questa guida]

CategoryHomepage