[C] Problema con i puntatori

[valeriobb87]

Lavoro con una macchina embedded e nel mio sistema un INT = 4 byte;
Devo accedere ad un indirizzo INT, ad esempio 0x0A000000 e recuperare il CHAR a quella locazione, poi accedere alla locazione subito successiva (0x0A000001)e recuperare anche quel valore sempre CHAR.

Quindi ho scritto:

char *p_loc, loc;

p_loc = (char *)0x0A000000;
loc = *p_loc;

// funziona correttamente e loc contiene correttamente il CHAR che mi aspetto, quindi proseguo con...

p_loc += 1;
loc = *p_loc;

// ...e qui non funziona la cosa

Ora, ma se p_loc punta ad un CHAR alla locazione 0x0A000000, secondo l'aritmetica dei puntatori, con "p_loc += 1" non dovrei accedere al byte di memoria subito successivo?
Come recupero il CHAR a 0x0A000001 utilizzando p_loc?

Grazie.

[oregon]

Non funziona in che senso?

Se

p_loc = (char *)0x0A000001;

funziona?

[valeriobb87]

Non funziona nel senso che: io so che valore è presente all'indirizzo 0x0A000001, ma invece mi viene restituito 0x00, se faccio come giustamente mi ha suggerito tu: p_loc = (char *)0x0A000001, funziona! Recupero il valore che mi aspettavo.

[oregon]

Qualche domanda

1) nel tuo sistema quanto è grande il char ?

2) se esegui p_loc += 1; ( oppure p_loc++; ) quanto vale p_loc dopo?

3) di che sistema parliamo precisamente?

[valeriobb87]

1) 1 CHAR = 1 byte
2) posso darti la risposta precisa domani sera, ora non ho modo di lavorarci
3) E' una psp (sony playstation portable)

Grazie mille per l'interessamento!

[oregon]

1) 1 CHAR = 1 byte

Sicuro? Hai provato con sizeof(char) ?

2) posso darti la risposta precisa domani sera, ora non ho modo di lavorarci

Ok

3) E' una psp (sony playstation portable)

Ok

Hai provato a leggere il valore intero e fare il controllo dopo con

int v = (int *)0x0A000000;


P.S. A che ti serve leggere il kernel ? Mi sembra che si sia il kernel in quella posizione ...

[valeriobb87]

Allora facciamo il punto della situazione, ho preparato un mini sorgente per riepilogare il tutto e risponderti alle domande; ho fatto due screen, uno con il dump della memoria (effettuato con un software per leggere la memoria) e l'altro screen è il programma in run-time sulla psp; rispondendo al tuo Ps., si con l'indirizzo 0x0a000000, siamo nel kernel, ma era puramente fittizio per fare facile l'esempio per chi leggeva.

#include <pspkernel.h>
#include <pspdebug.h>

PSP_MODULE_INFO("Prova per Html.it", PSP_MODULE_USER, 1, 1);
// definisce un alias per la funzione pspDebugScreenPrintf 
#define printf pspDebugScreenPrintf 

int main() {

  // inizializzazione per l'uso dello schermo della PSP
  pspDebugScreenInit();
  // ritorno alla xmb mediante pressione pulsante home 
  SetupCallbacks();
   
  char *p_loc, loc;
  
  printf("Un char vale: %d \n\n", sizeof (char));
  
  p_loc = (char *)0x08800002;
  loc = *p_loc; 
  printf("0x08800002: %x \n\n", loc);
  
  p_loc = (char *)0x08800001;
  loc = *p_loc;
  printf("0x08800001: %x \n\n", loc);
  
  p_loc++;
  loc = *p_loc;
  printf("p_loc: %p ", p_loc);
  printf("->: %x \n\n", loc);
  
  char *nuovo_p;
  nuovo_p = p_loc+1; // dopo p_loc++, p_loc dovrebbe valere 0x08800003
  loc = *nuovo_p; // quindi loc dovrebbe valere 0x3c
  printf("nuovo_p: %p ", nuovo_p);
  printf("->: %x \n\n", loc);
  
  // ti prego spiegami il risultato di questa!!!
  p_loc = (char *)0x08800000;
  loc = *p_loc; 
  printf("0x08800000: %x \n\n", loc); 

  // ferma il thread bloccando il risultato a schermo
  sceKernelSleepThread(); 

  return 0;
}

Cioè bo, qui è tutto perfetto, mi sa che ho fatto una gaffe... non ne sono sicuro ma mi sa che tentavo di fare una cosa del genere: p_nuovo = (char *)p_loc+1;

Un'ultima cortesia, riesci a spiegarmi perchè l'output dell'ultimo printf??

[valeriobb87]

screenshot del programma in run-time

[oregon]

Mi sembra tutto ok ...

Per l'ultima printf la spiegazione è semplice ... dato che devi operare con dei byte (senza considerare il loro segno) allora dovrai usare in tutto il programma degli

unsigned char

altrimenti il segno viene automaticamente preso in considerazione e dato che 80 esadecimale è un numero negativo, il bit del segno viene esteso al valore a 32 bit e mostrato con tutte quelle F