Newsgroup: it.comp.lang.c++
Titolo: Cosè  *(int *)  ?

Forse un po' OT, scusate.
Cosa vuol dire:
#define DCR0 (*(volatile unsigned int *)(0x17))
puntatore ad un intero che punta la locazione 0x17?
Sto convertendo un programma da un compilatore ad un'altro.
Ho la funziona:
void Rampa (volatile unsigned int *PWM);
che viene chiamata dal main con:
Rampa(&DCR0);
Il mio problema è che il file.h che includo (che NON posso cambiare) mi 
definisce DCR0 nel primo caso come:
#define DCR0 (*(volatile unsigned int *)(0x17))
mentre adesso è definito come:
volatile int DCR0 @0x17;

 volatile int DCR0 @0x17;
Questo e' addirittura non standard: immagino che @0x17 significhi il
valore della locazione assoluta 0x17. Le due notazioni sembrano
indicare la stessa cosa. Dov'e' il problema?
Ciao,
Nicola

 volatile int DCR0 @0x17;
non conosco il formalismo della chiocciola prefissa. E' forse un 
modo per dereferenziare un puntatore "literal" ?
Interessante nel caso !
Assomiglia alle direttive dell'assembler inline tipo
WORD PTR [0017]
anzi DWORD PTR, dato che ormai si lavora a 32 bit di default
se puoi spiega quella dichiarazione con la chiocciola prefissa
ciao
Soviet

Nicola Musatti ha scritto:
chiedo scusa, ma il refresh dei nuovi messaggi è lento e/o sono 
lento a scrivere, per cui la mia risposta è inutile.
MA già che ci sono chiedo a te che conosci bene lo standard .... 
quella chiocciola nella dichiarazione di un literal intero 
significa dereferenziare un indirizzo assoluto e quindi 
riferirsi a una locazione di memoria fissa ?
E se si, che garanzie ci sono che il sistema operativo, 
qualunque sia, non ti risponda con un bel 'vaffa' se un 
programma generico, senza privilegi particolari, presupponga di 
leggere/scrivere ovunque gli pare nella memoria ?
Cioè, mi spiego meglio, ci sono delle direttive del compilatore 
per produrre eseguibili che richiedano certi privilegi al 
lancio, come l'accesso a risorse tipicamente globali di sistema ?
ciao
Soviet


 lancio, come l'accesso a risorse tipicamente globali di sistema ?
Questi non dovrebbero essere affari del compilatore. Concedere o meno
determinati permessi spetta al sistema operativo.
Ciao,
Nicola

 Soviet
Calma calma calma! Intanto grazie mille a Soviet e Nicola x 
l'interessamento!
Il codice che vi ho postato è di un micro...a 8 bit della ST!
Queste fantastiche definizioni:
#define DCR0 (*(volatile unsigned int *)(0x17))
e
volatile int DCR0 @0x17;
sono definite dalla casa costruttrice del compilatore, in questo caso 
uno Hiware e l'altro Cosmic. L'accesso alla memoria è volutamente assoluto.
"Volatile" và messo nelle variabili modificate in interrupt xchè a volte 
il compilatore, se non metti volatile, ti cava la variabile xchè non 
capisce quando viene modificata (spiegazione un tanto al kilo).
Ho postato qui, OT appunto, xchè ho qualche carenza di C base e speravo 
in un errore grossolano tipo...aver uguagliato puntatori a interi col 
valore stesso contenuto nella locazione di memoria.
Il compilatore comunque risponde:
#error cpst7 interrupt_vector.c:227(12+4) incompatible argument type
Grazie ancora

 con linguaggi ibridi su più piattaforme ?
UNIX e discendenti hanno le shared libraries.
Ciao,
Nicola

 #error cpst7 interrupt_vector.c:227(12+4) incompatible argument type
Non e' che il problema e' semplicemente dovuto al fatto che una delle
due definizioni si riferisce ad un unsigned int mentre l'altra ad un
int dotato di segno?
Ciao,
Nicola

 Il codice che vi ho postato è di un micro...a 8 bit della ST!
Cosa sarebbe la ST? Forse un Atari ST?
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg
The EMG Music page:         
http://www.emagsoftware.it/emgmusic
 

 in sistemi diversi da windows ?
OS/2 ha le DLL esattamente come Windows.
UNIX e suoi derivati/simili hanno le "Shared Libraries" (.so) che piu' o 
meno sono la stessa cosa.
MacOS immagino abbia qualche analogo (sicuramente ha le .so essendo 
ormai basato su UNIX, ma mi viene il dubbio se abbia anche qualche altro 
metodo pre OS X).
...
  bye
	av.

con linguaggi ibridi su più piattaforme ?
Che intendi per "linguaggi ibridi" ?

Ciao,
mi e capitato di usare volatile proprio nelle istruzioni
all'interno di routine "chiamate" via interrupt ( Es. seriale )
si usa per assicurare che il valore venga sempre
letto dalla locazione originale e aggiornata.


 Che intendi per "linguaggi ibridi" ?
nel senso che sto scrivendo pezzi di codice tipo patchwork (in 
VB e VC++), sfruttando il fatto che il codice C++ può essere 
compilato in forma di DLL integrabile facilmente all'eseguibile 
VB (oddio facilmente, a essere sincero ho avuto, e di certo 
altri ne avrò, non pochi problemi con le convenzioni di chiamata 
diverse e la decorazione dei nomi, arginata grazie a un utility 
che si chiama depends ed esplora le DLL mostrando i veri nomi 
decorati che ci sono dentro).
In un sistema che non avesse il concetto di DLL, non avrei 
saputo immaginare come poter scrivere un'applicazione 
sviluppata, ad es. in due pezzi, tipo la GUI in VB rad e il 
nocciolo duro di calcolo e accesso ai file in C++ (che facilita 
parecchio le cose a basso livello).
Cmq, con questo ti ringrazio e pure tutti quanti mi hanno 
risposto malgrado la non aderenza al manifesto di questa serie 
di post.
Roger and Out
Soviet

parecchio le cose a basso livello).
Questo perché, a quanto pare (e per fortuna, da un certo punto di
vista), ormai, gli ambienti di sviluppo prentendono di fare tutto.  Un
tempo, sviluppando a riga di comando, tutti producevano file oggetto
integrabili tra loro mediante il linker e si poteva tirare su un
programma scrivendone le parti in 10 linguaggi diversi.

 int dotato di segno?
GRANDEEE! Ho tolto unsigned e compila!
Grazie.

 Cosa sarebbe la ST? Forse un Atari ST?
www.st.com
microcontrollori... piccole CPU

 microcontrollori... piccole CPU
Ah, ok, grazie.


 metodo pre OS X).
OSX ha le dyndl (non i .so) e i framework, che sono qualcosa di + che le 
classiche librerie standard in quanto includono una struttura di 
directory che puo' contenere anche gli header per la compilazione, 
eventuali librerie da cui dipende il framework ed eventuali file di dati.
I framework diciamo che stanno alle shared library come gli application 
bundle stanno agli eseguibili :)
Bye,
  Gabry