riconoscere in una sequenza di byte che va da A a F dei byte noti

[distuning]

Ciao ragazzi , 

Pongo nuovo quesito    : come possiamo fare questa operazione in modo semplice ?

Ho una variabile filexxx che contiene un file letto , conosco gli indirizzi da A fino a G in cui devo cercare una sequenza di 5 byte noti es: 240 , 98 ,1,1,1 se presenti ....
Una volta individuata tale sequenza devo risalire all'indirzzodove e' posizionato il 4 byte ( che e' 1 ) 

grazie anticipatamente   

[md9327]

Se dove dirla tutta, non ci ho capito un'H.

Nella testata parli di byte da A a F, e poi dopo scrivi da A a G. Prima pensavo ad una conversione di valori hex, poi hai confuso il discorso...

A parte la lettura del file, che penso sia quindi un binario, per indirizzi cosa intendi?

Ok per cercare alcuni byte definiti, questo lo puoi fare confrontandone il valore con Asc(<stringa>, <pos>), o comunque la sequenza ascii di 5 valori binari.

Anche l'identificare il singolo byte è semplice, c'è la funzione apposita in Gambas, che ritorna True se il bit indicato è 1, altrimenti False. Adesso non ho sottomano Gambas, ma mi pare la funzione si chiami BitTst(<byte>, <pos>).

[distuning]

ciao , cerco di farmi capire meglio e mi scuso se posto un tantino in modo confusionale....

allora .... ho una variabile filexxx dichiarata come

DIM filexx as file

all'interno vi e' depositato il contenuto di un dato file binario .

Conosco di questo filexxx la lunghezza che va da 0 a 1FFFF in hex ( file lungo 2097151 byte) , siccome al suo interno es ( dalla posizione del byte 534896 alla posizione 535465) vi e' sicuramente la sequenza dei 5 byte che mi interessa cercare ( 240 -98 -1 -1-1) , mi occorre che il porgramma mi faccia sapere a quale indirizzo corrisponde il 4° byte trovato della sequenza dei 5 byte interessati ,es potrebbe darmi che il 4° byte che ha come valore 1 sia posto alla locazione 53500 !

in pratica il programma mi deve far sapere la posizione del 4° byte ricercando la seguenza da menindicata come campione nelle posizionitra il byte 534896----->535465

se ho ripostato male il quesito fate sapere ....

gentilissimi

[md9327]

ciao , cerco di farmi capire meglio e mi scuso se posto un tantino in modo confusionale....

allora .... ho una variabile filexxx dichiarata come

DIM filexx as file

all'interno vi e' depositato il contenuto di un dato file binario .

Conosco di questo filexxx la lunghezza che va da 0 a 1FFFF in hex ( file lungo 2097151 byte) , siccome al suo interno es ( dalla posizione del byte 534896 alla posizione 535465) vi e' sicuramente la sequenza dei 5 byte che mi interessa cercare ( 240 -98 -1 -1-1) , mi occorre che il porgramma mi faccia sapere a quale indirizzo corrisponde il 4° byte trovato della sequenza dei 5 byte interessati ,es potrebbe darmi che il 4° byte che ha come valore 1 sia posto alla locazione 53500 !

in pratica il programma mi deve far sapere la posizione del 4° byte ricercando la seguenza da menindicata come campione nelle posizionitra il byte 534896----->535465

se ho ripostato male il quesito fate sapere ....

gentilissimi

Bè, intanto la variabile filexxx non è il contenuto del file, ma solo il buffer di scambio con il file presente sul sistema.
Quello che fai è aprire lo stream, con cui leggere il contenuto del file, e depositarlo in qualche altra variabile, es. una stringa.
Riguardo al contenuto, l'oggetto File non mi pare abbia funzioni che fanno ricerche interne. Semmai puoi usare String, o le funzioni di manipolazione stringa, per cercare una determinata sequenza di caratteri.
Tieni conto che, se il contenuto del file è binario, questo và letto con la sintassi READ e scritto con WRITE, per evitare i controlli classici su file in formato testo.
Detto questo, una volta caricato il contenuto del file in memoria (in una variabile), devi tener conto che questo contiene solo una sequenza di byte, per cui è difficile intercettarli tramite le classiche funzioni stringa. Ci puoi provare, ma penso sia meglio gestire un loop (FOR...NEXT), in cui viene verificato il singolo byte a livello numerico (Asc()), e cercando di trovare la concatenazione giusta. La posizione in cui viene trovata la sequenza c'è l'hai di conseguenza con il numero di loop eseguiti fino a quel momento (FOR <n> = 1 TO <dimensione totale>, dove <n> è appunto la posizione).
Tieni conto che se il file è molto grande, un loop del genere, con i relativi controlli, potrebbe esser pesante, e metterci parecchio tempo. Il mio consiglio è di provare con dei test su piccole porzioni di dati, anche per ottimizzare il codice di analisi e estrapolazione.

[vuott]

...siccome al suo interno es ( dalla posizione del byte 534896 alla posizione 535465) vi e' sicuramente la sequenza dei 5 byte che mi interessa cercare ( 240 -98 -1 -1-1) , mi occorre che il porgramma mi faccia sapere a quale indirizzo corrisponde il 4° byte trovato della sequenza dei 5 byte interessati....

Da quel che pare di capire a me, questi 5 byte non sono posti in sequenza immediata l'uno dopo l'altro, bensì disseminati - seppur in quell'ordine di "apparizione" - in un tratto molto vasto del file: nel tuo esempio ben 596 byte. ...se no come farebbero con tutta la buona volontà cinque byte del file ad occupare 596 byte ?

Se i cinque byte fossero posti esattamente, senza soluzione di continuità, uno immediatamente dopo l'altro, non sarebbe per niente difficile individuarli. Ma il fatto che sono disseminati ciascun byte in modo separato rispetto al precedente ed al successivo di quell'ordine, rende la cosa difficile. Però, come ci ha lasciato intendere md9327 qualcosa si può fare. Le strade possibili, come sempre, sono più di una.

[distuning]

ciao vuott , la sequenza dei 5 byte da me indicati sono posti precisamente in ordine uno dopo l'altro  ! solo che questa sequenza di 5 byte nota e locatain quel tratto che in cui devo farle cercare dal sw !


0 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 240 98 1 1 1 xxxxxxxxxxxxxx 1FFFFF

[vuott]

ciao vuott , la sequenza dei 5 byte da me indicati sono posti precisamente in ordine uno dopo l'altro  !

0 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 240 98 1 1 1 xxxxxxxxxxxxxx 1FFFFF

ahh, e allora non è difficile: qualcosa te l'ha già accennata md9327. Puoi anche provare un percorso del genere:

Codice: gambas [Seleziona]

Public Sub Button1_Click()

 Dim fl As File  
 Dim by As Byte
 Dim a As New Integer[]    ' prima avevo commesso un grave errore scrivendo "New Byte[]", non va bene: il perché è spiegato in un successivo messaggio.
 Dim j As Integer
  
 fl = Open "percorso del mio file" For Read  

' Procedo con il caricarmi nell'array ogni singolo byte del file:  
 While Not Eof(fl)
   Read #fl, by  
   a.Add(by)           
 Wend  
   
 fl.Close


' Compie un ciclo contando dall'indice 3 (altrimenti avrò un errore "Out of Bounds") fino all'ultimo indice dell'array:
    For j = 3 to a.Max

' Il "senso" del seguente IF è questo: se l' elemento dell'attuale indice è 1,
' e l'elemento immediatamente precedente è anch'esso 1, ed il terzultimo è uguale a 98,
' ed il quartultimo è uguale a 240...... e quindi sommati = 340...
      If a[j] + a[j - 1] + a[j - 2] + a[j - 3] = 340 then
'...allora....
        Print "Il 2° byte num. 1 della *sequenza dei cinque* si trova all'interno del file nella posizione n. "; j
' Esce dal ciclo, così risparmiamo tempo:
        Exit
     Endif

   Next

End

[sotema]

Scusa vuott, ma
If a[j] + a[j - 1]...
nel caso di j=0 ti dovrebbe generare l'errore "out of Bound", forse volevi scrivere If a[j] + a[j + 1]...

[vuott]

Scusa vuott, ma
If a[j] + a[j - 1]...
nel caso di j=0 ti dovrebbe generare l'errore "out of Bound", forse volevi scrivere If a[j] + a[j + 1]...

Sì, infatti mi hai anticipato, poiché stavo appena andando a correggere l'inizio del conteggio.

Quindi sarà

Codice: gambas [Seleziona]

For j = 3 to a.Max  

....oppure - come suggerisce l'amico sotema - "guardi" agli elementi successivi rispetto all'elemento che si sta considerando, e puoi così partire con il ciclo For da 0:

Codice: gambas [Seleziona]

For j = 0 to a.Max  

però in questo caso, ovviamente, l'elemento che stai considerando è il primo della "sequenza dei cinque", ossia quello contenente il valore 240 ( e non più il secondo 1 come era nella precedente soluzione che "guardava" agli elementi retrostanti). Anche la riga del Print con tale soluzione ovviamente cambierà:

Codice: gambas [Seleziona]

Print "Il 2° byte num. 1 della *sequenza dei cinque* si trova all'interno del file nella posizione n. "; j + 3

[distuning]

Ciao Vuott ,

l'istruzione

if a[j] + a[j +1] + a[j +2] + a[j+3] = 340 then

non dovrebbe essere cosi postata ?

if a[j] + a[j +1] + a[j +2] + a[j+3] + a[j+4] = 341 then ' 240 + 98+1+1+1 = 341 ??

print " il quarto byte che vale 1 e' posto all'indirizzo : " ; j +3

solo che in entrambi i casi salta l'errore " out of bound"

funziona solo se si fa cosi' :

if a[j]  = 240 then 'ovviamente se cerco il dato 240

print " il  byte che vale 240 e' posto all'indirizzo : " ; j

----------------------------------------------------------------


facendo in questo modo molto grezzo il discorso fila ma  e un tantino uno schifo 

FOR j = 534850 TO 535480
IF a[j] = 240 THEN
IF a[j + 1] = 98 THEN
IF a[j + 2] = 1 THEN
IF a[j + 3] = 1 THEN
IF a[j + 4] = 1 THEN

PRINT " il byte di controllo da me cercato  e' alla posizione : "; j + 3

EXIT
ENDIF
ENDIF
ENDIF
ENDIF
ENDIF 
NEXT




a voi  

[vuott]

Io farei così:

Codice: gambas [Seleziona]

Public Sub Button1_Click()

 Dim fl As File
 Dim a, c As Byte
 Dim b As New Integer[]
 Dim d As Integer

 fl = Open "percorso_e_nome_del_file" For Read

' Punterò successivamente con Seek nell'intervallo di byte del file
' compreso fra il byte 534896 ed il byte 535465:
   For a = 534896 To 535465
' Pattino con grazia lungo quel tratto di file con Seek:
     Seek #fl, a
' Leggo il byte di ciascun indice toccato dal puntatore Seek,
' e lo carico nella variabile "c"....
      Read #fl, c
'...nonché nell'array "b[]":
      b.Add(c)
' La variabile "d" deve essere > 2, altrimenti dopo avremo un errore
' del tipo "Out of Bounds". Infatti dovremo avere almeno effettuato 4 cicli.
' Il 4° ciclo del For ci consentirà di verificare l'elemento "b[d - 3]":
     If d > 2 Then
' Se la somma...etc...etc... (vedi mio intevento precedente):       
       If b[d] + b[d - 1] + b[d - 2] + b[d - 3] = 340 Then  
'...allora....  
          Print "Il 2° byte num. 1 della *sequenza dei cinque* si trova all'interno del file nella posizione n. "; a
          Exit
      Endif
    Endif

' Incrementiamo la variabile "d" per effettuare il conteggio "parallelo" d'appoggio:
    Inc d

  Next

End

[md9327]

Il problema, come pure evidenziato, è che potrebbe andare in errore.
La sequenza non è detto che la si trovi, e potresti trovarne una incompleta a fine file, per cui l'indirizzamento per byte potrebbe andare in errore, se con quei "+" si và oltre l'ultimo byte.

Le alternative potrebbero essere tre, ovvero:

1) creare una variabile, che contiene la sequenza esatta da cercare. Tramite poi Pos() si và a cercarla all'interno del buffer. Pos() ritorna la posizione iniziale della stringa, partendo da 1, altrimenti restituisce 0 (non trovata).
2) mettere un contatore, in modo che ad ogni byte trovato sequenzialmente, si và a popolare questo contatore che, appena raggiunge il limite (ovverossia il numero di byte della sequenza), si ha il punto dove l'ha trovata.
3) un misto dei due punti sopra ovvero: usando un WHILE...WEND, popolare una stringa vuota fino al raggiungimento dell'intera sequenza, e appena completata uscire, tenendo anche un contatore di lettura per la posizione.

Insomma di possibilità ce ne sarebbero pure altre... Forse la prima è la più veloce, se funziona... 

[vuott]

l'istruzione
if a[j] + a[j +1] + a[j +2] + a[j+3] = 340 then
non dovrebbe essere cosi postata ?
if a[j] + a[j +1] + a[j +2] + a[j+3] + a[j+4] = 341 then ' 240 + 98+1+1+1 = 341 ??
print " il quarto byte che vale 1 e' posto all'indirizzo : " ; j +3

Diciamo che è più dettagliata, puntuale rispetto al gruppo di byte da individuare.

solo che in entrambi i casi salta l'errore " out of bound"

Forse ho capito l'errore dove sta. Ho commesso uno stupido errore.  

La dichiarazione: Dim a As New Byte[]   non va bene, poiché avremo delle somme che mooolto probabilmente supereranno il valore 255, devi cambiare in:

Codice: gambas [Seleziona]

Dim a As New Integer[]  

La verifica andava quindi all'infinito e "sfondavi", come pure ha fatto rilevare md9327 , il tetto degli indici dell'array.

Chiedo scusa.  

Ora sono andato a modificare quell'errore in quel messaggio.

[distuning]

tutto ok funziona ! bene senza dare errore !

vuott e anche a tutti coloro che sono intervenuti 

a breve nuovo quesito .....

comunque non sono i soliti esempi facili di text , label ecc.... tali post sono utili a tutti per fare cosette un tantino piu' professionali e strane in un certo senso.

grazie come sempre

[vuott]

a breve nuovo quesito .....

...ho come l'impressione di essere tornato a scuola !