Newsgroup: it.comp.os.linux.development
Titolo: [GDB] Modificare una variabile char[]

Ciao a tutti,
sto tentando di capire come modificare all'interno del gdb (se e'
possibile) una variabile di tipo 'stringa' ossia un oggetto del tipo
char pippo[20] ad esempio.
se faccio un set pippo = "mia_stringa" ottengo un errore del tipo
'invalid cast'
Ho provato in vari modi, anche inserendo i codici hex con lo slash
('\030\034...'), dato che e' il formato in cui il gdb mostra le
stringhe, ma niente, probabilmente sbaglio la sintassi ma non riesco a
trovare indicazioni su come fare...
Grazie a tutti per eventuali dritte
CiaoCiao 
  Sergio "33%" Borghese


Vado a memoria.
set pippo[0] = 'm'
set pippo[1] = 'i'
...
Ciao,
-- 
        Roberto Divia`              Love at first sight is one of the greatest
Dep:PH Bat:53 Mailbox:C02110      labour-saving devices the world has ever seen
Route de Meyrin 385               ---------------------------------------------
Case Postale                                Phone:  
+41-22-767-4994
CH-1211 Geneve 23 CERN                      Fax:    
+41-22-767-9585
Switzerland                                 E-Mail: 
Robert...@cern.ch

 'invalid cast'
Infatti ... pippo e` un array di char mentre "mia_stringa" e` un 
puntatore a char.
Te lo dice pure ... 'invalid cast'. Quindi basta "castare" (oddio che 
termine che mi e` venuto!)
set pippo = {char} "mia_stringa"
Ciao, spero di essere stato utile.

Sinceramente speravo ci fosse un metodo meno 'brutale' ;)
Ho fatto uno script gdb per settare tutta la mia stringa byte per byte
come suggerisci tu, ma la trovo una soluzione 'brutta'.
Forse pero' non esiste proprio un altro metodo... :(
Grazie 
  Sergio "33%"

Ed infatti funziona!! :)
Grazie mille, sbagliavo nel tentare di fare il cast, usavo le parentesi
tonde, stile C
Sergio "33%"

 termine che mi e` venuto!)
A norma di standard ed a discrezione del compilatore etc. etc. ,
"mia_stringa" potrebbe essere in pagine di memoria read-only...
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Dept. of Physics, Univ. of Padova, Italy              ROT13: 
ybe...@cq.vasa.vg

 "mia_stringa" potrebbe essere in pagine di memoria read-only...
Mmmmm ... a ridaje ... siamo nel GDB non in un compilatore!
set tu fai dal GDB:
set pippo = {char} "mia_stringa"
la stringa "mia_stringa" non sta certo in una pagina read-only!
Il GDB la legge dal prompt di input, se la mettera` sicuramente in un 
buffer allocato o quant'altro ... insomma e` una cosa dinamica la 
gestione delle espressioni nel gdb!!!!!

 Mmmmm ... a ridaje ... siamo nel GDB non in un compilatore!
Premetto che non conosco gdb, ma mi permetto di dissentire...
Insomma, stai sottintendendo che un compilatore sappia preventivamente
che il codice generato verra' eseguito sotto gdb e non standalone?  E
che, avendo previsto il futuro, si comporta in modo differente?
Se al compilatore e' permesso collocare variabili in memoria read-only
e se il tentativo di modificare memoria read-only produce un errore a
runtime, non vedo che differenza ci sia se ad effettuare il tentativo
di modifica e' un programmatore sprovveduto (mia_stringa[2] = 'a';) o
un utente sprovveduto di gdb (set mia_stringa[2] = 'a').


 un utente sprovveduto di gdb (set mia_stringa[2] = 'a').
No no ... scusa, forse ci siamo spiegati/capiti male!
Torniamo a quello che diceva sergico: lui ha un char pippo[20]. Se 
questa variabile fosse in una sezione read-only della memoria 
(basterebbe dichiararla const), siamo tutti d'accordo, che fare pippo[0] 
= 'a' produrrebbe a run-time un bel Segmentation Fault.
Nella tua risposta a me, dicevi (facendo riferimento al comando GDB set 
pippo = {char} "mia_stringa" che avevo detto io:
"mia_stringa" potrebbe essere in pagine di memoria read-only...
No, "mia_stringa" non e` sicuramente in una sezione read-only. Viene 
letta in input dal prompt del comandi e messa chissa` dove in un qualche 
buffer e poi valutata dal GDB.
Che poi l'utente che usa il GDB voglia fare il set di "mia_stringa" su 
una variabile read-only ... quella e` un'altra cosa!!!! In teoria 
dovrebbe dare errore. Pero ...
Guarda cosa ho scoperto proprio adesso (non ci avevo mai fatto caso e 
non lo sapevo). Tipico esempio in C:
char pippo1[20] = { 0 };
const char pippo2[20] = { 0 };
int main (void)
{
   pippo1[0] = 'a';   // OK!
   pippo2[0] = 'a';   // Seg fault!
   return 0;
}
Compilato (fornisce un warning per via del set alla variabile const) ed 
avviato fornisce un bel Segmentation Fault.
Avviato da debugger, se faccio dal prompt all'interno del GDB:
set pippo2 = {char} "mia_stringa"
funziona!!! E se poi faccio:
print pippo2   mi visualizza "mia_stringa".
Non e` che il GDB carica l'eseguibile in modo da rendere le sezioni 
marcate come read-only ... scrivibili????? (domanda per i guru)

 marcate come read-only ... scrivibili????? (domanda per i guru)
Non lo so perché non conosco neanche io GDB, ma mi sembra strano che prenda
di tali iniziative (ovvero che renda modificabile, ciò che il compilatore ha
decretato non modificabile).
In ogni caso, la tua risposta iniziale, non è la motivazione del problema.
"Infatti ... pippo e` un array di char mentre "mia_stringa" e` un
puntatore a char."
A un array di caratteri, solo durante l'inizializzazione, è possibile
assegnare un puntatore a caratteri.
char pippo[20] = "sssss";
Questa situazione (che è uno dei tre casi in cui il nome di un array non
decade in puntatore al suo primo elemento) fa sì che l'array venga
inizializzato con i caratteri puntati.
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 inizializzato con i caratteri puntati.
Chiedo scusa se ho detto qualcosa che poteva essere frainteso o non 
capito bene. Neanche io conosco perfettamente il GDB, nonostante siano 
ormai parecchi anni che lo uso per lavoro.
Tutto quello che hai detto lo so benissimo anche io (e` la teoria del 
linguaggio "C"). Ma qui, e mi riferisco sempre al primo post di sergico, 
si sta parlando del GDB. Esso mette a disposizione il comando "set VAR = 
EXP" che valuta una espressione e la assegna ad una variabile".
Se al GDB non sta bene un set pippo = "mia_stringa" presumo che sia 
perche` vede le due entita` come diverse. Da qui deriva il cast (tra 
parentesi graffe come richiede il GDB) che ho spiegato e che risolve, 
nel GDB, la cosa.
Non vedo una attinenza con il char pippo[20] = "sssss", che e` 
perfettamente lecito in "C" per l'inizializzazione di una variabile ma 
che non c'entra niente con il GDB.

 perche` vede le due entita` come diverse. 
E avrebbe pure ragione, dato che cerchi di modificare un array (i.e. un
l-value non modificabile), ma non capisco in che modo il cast possa
risolvere la cosa.  Bisognerebbe capire esattamente che cosa fa il gdb in
questi casi.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 questi casi.
Senza dimenticare che - alla fine - e` il programma in C che deve
manipolare le entita` modificate da GDB. Come se queste fossero state
allocate dal compilatore, in accordo alle loro dichiarazioni ;-)
