recursivo - Coincidencia de patrones binarios en C

programa que convierte de decimal a binario en c

Question

Actualmente estoy desarrollando un programa de C que necesita analizar estructuras de datos personalizadas, afortunadamente sé cómo están estructuradas, sin embargo, no estoy seguro de cómo implementar mi analizador sintáctico en C.

Cada una de las estructuras tiene una longitud de 32 bits y cada estructura se puede identificar por su firma binaria.

Como ejemplo, hay dos estructuras particulares que me interesan y tienen los siguientes patrones binarios (x significa 0 o 1)

 0000-00xx-xxxx-xxx0
 0000-10xx-10xx-xxx0

Dentro de estas estructuras, los bits ''x'' contienen los datos reales que necesito, así que esencialmente necesito una forma de identificar cada estructura en función de cómo se escriben los bits dentro de cada estructura.

Entonces como ejemplo en pseudo-código:

if (binaryPattern = 000010xxxxxxxxx0) {
do something with it;
}

Supongo que leerlos como enteros, y luego realizar algún tipo de enmascaramiento de bits sería el camino a seguir, pero mi conocimiento de C no es genial, y tal vez una simple operación OR lógica lo haría, pero solo quería un poco consejos para hacer esto antes de comenzar.

Gracias

Muchas gracias a todos los que han respondido, ¡muy útil!

Answer 1

Creo que puedes ponerles una máscara de bits, poniendo 1 en la posición donde tienes un bit especificado, 0 cuando el bit no importa.
Ejemplo:

000000xxxxxxxxx0    000010xx10xxxxx0
1111110000000001    1111110011000001

Luego use este patrón secundario como con la operación & bitwise y compárelo con el valor que necesita (simplemente ponga x en cero).
El ejemplo para el segundo patrón debería ser:

if( (value&0b1111110011000001)== 0b0000100010000000){
     //pattern found
}

Answer 2

Lo que necesitas es un Binario AND (&)

if( (value & matchPattern) == matchPattern ) {
   // do something with it.
}

Como dijiste, son 32 bits, así que supongo que usas algo como uint32_t. Si este es el caso, podrías tener algo como esto:

uint32_t value = 0xF0F0ABCD;
//                            0xFOF0XXXD X = data
uint32_t const matchPattern = 0xF0F0000D;
if( (value & matchPattern) == matchPattern) {
     uint32_t use = value & 0x0000FFF0; // extracts the XXX part
}

y así

Answer 3

Para verificar si sus datos coinciden con un patrón binario específico, primero puede enmascarar los bits que no son de firma y luego compararlos con una plantilla de firma.

Por ejemplo, para verificar si sus datos coinciden con la firma 0000 10xx 10xx xxx0:

1. Y sus datos de entrada con 1111 1100 1100 0001 (la máscara)
2. compruebe si la salida es igual a 0000 1000 1000 0000 (la plantilla)

Para ilustrar con algunos datos de muestra:

DATA_1   0010 1011 1101 1100                DATA_2   0000 1011 1010 1100
  MASK   1111 1100 1100 0001  &               MASK   1111 1100 1100 0001  &
        --------------------                        --------------------
         0010 1000 1100 0000 (NO_MATCH)              0000 1000 1000 0000 (MATCH)
        --------------------                        --------------------

Por lo tanto, cada una de las reglas podría representarse mediante un par máscara-plantilla y todo lo que necesita es una función / operación que aplique la operación anterior a sus datos para verificar si es una coincidencia.

Answer 4

Por cierto, solo mostró patrones de 16 bits, no de 32 bits ...

De todos modos, puede definir máscaras que representen qué parte del patrón le interesa. Realice un Y a nivel de bit con su valor y la máscara, y si el resultado es el patrón de prueba, ha encontrado lo que desea.

#define PATTERN1 0x0000
#define MASK1 0xfc01

#define PATTERN2 0x0880
#define MASK2 0xfcc1

if ((value & MASK1) == PATTERN1) {
  // have pattern 1
}
else if ((value & MASK2) == PATTERN2) {
  // have pattern 2
}

Si tiene más patrones, obviamente es mejor colocar los patrones y máscaras en una tabla y recorrerlos.