El CPU virtual consta de varios registros:
4 registros utilizables a modo usuario, el registro acumulador (*), puntero de instrucción, memoria de código y memoria de datos y un último registro de tamaño byte usado para establecer comparaciones.

La memoria de datos, los 4 registros de usuario y el registro acumulador son de tipo short int, esto quiere decir que pueden alcanzar valores desde 0x0000 hasta 0xFFFF, menos la memoria, que alcanza valores desde 0x1000 hasta 0x2000 (esto son 4kB).

La memoria de datos está programada para en un futuro poder utilizar varias en una misma CPU usadas como "módulos". Para utilizarla un ejemplo podría ser:
putl 1001 BB (guardar en posicion 1 valor 0xBB).
Es posible que en un futuro se junten las dos memorias (memoria de código y memoria de datos).

---

0x00	halt	detiene el cpu
0x01	lit	cargar en acumulador un valor inmediato
0x02	load	cargar en acumulador valor de un registro
0x03	store	almacenar valor acumulador en un registro
0x04	inc	incrementar por 1 el acumulador
0x05	dec	decrementar por 1 el acumulador
0x06	putl	poner en memoria un valor inmediato
0x07	putr	poner en registro un valor de memoria
0x08	geta	cargar en acumulador un valor de memoria
0x09	getr	cargar en registro un valor de memoria
0x0A	cmpl	comparar acumulador con valor inmediado. establece flag
0x0B	cmpr	comparar acumulador con valor registro. establece flag
0x0C	jmp	saltar a direccion de codigo (inicio == 0x00)
0x0D	jmpl	saltar a direccion de codigo si flag == 1 ( < )
0x0E	jmpe	saltar a direccion de codigo si flag == 2 ( = )
0x0F	jmpg	saltar a direccion de codigo si flag == 3 ( > )

---

#========================================
# CALCULAR RESTA DE DOS NUMEROS
#========================================
# Usando 2 registros se pueden hacer
# funciones de resta de números.
# resultado: r0
#========================================
 
# Inicializacion de los datos
 
lit 25		# ac: 25
store r0	# r0: 25
lit 17		# ac: 17
store r1	# r1: 17
lit 0		# ac: 0
 
# Bucles
 
load r1		# ac: r1
dec		# ac: ac--
store r1	# r1: ac
load r0		# ac: r0
dec		# ac: ac--
store r0	# r0: ac
 
lit 1		# ac: 1
cmpr r1		# comparar ac & r1
jmpg 16		# ac > r1 --> jmp 16
jmp 6 		# jmp 6
 
halt		# stop

char codigo[] = {0x01, 25, 0x03, 0x00, 0x01,
					   17, 0x03, 0x01, 0x01, 0x00,
					   0x02, 0x01, 0x05, 0x03, 0x01,
					   0x02, 0x00, 0x05, 0x03, 0x00,
					   0x01, 0x01, 0x0B, 0x01, 0x0F,
					   28, 0x0C, 10, 0x00};

#========================================
# CALCULAR SUMA DE DOS NUMEROS
#========================================
# Usando 2 registros se pueden hacer
# funciones de suma de números.
# resultado: r0
#========================================
 
# Inicializacion de los datos
 
lit 17		# ac: 17
store r0	# r0: 17
lit 25		# ac: 25
store r1	# r1: 25
lit 0		# ac: 0
 
# Bucles
 
load r1		# ac: r1
dec		# ac: ac--
store r1	# r1: ac
load r0		# ac: r0
inc		# ac: ac++
store r0	# r0: ac
 
lit 1		# ac: 1
cmpr r1		# comparar ac & r1
jmpg 16		# ac > r1 --> jmp 16
jmp 6 		# jmp 6
 
halt		# stop

char codigo[] = {0x01, 17, 0x03, 0x00, 0x01,
					   25, 0x03, 0x01, 0x01, 0x00,
					   0x02, 0x01, 0x05, 0x03, 0x01,
					   0x02, 0x00, 0x04, 0x03, 0x00,
					   0x01, 0x01, 0x0B, 0x01, 0x0F,
					   28, 0x0C, 10, 0x00};

#========================================
# CALCULAR MULTIPLICACION DE DOS NUMEROS
#========================================
# Utilizando 3 registros (incluso menos) se
# pueden hacer funciones de multiplicación
# de números.
# resultado: r2.
#========================================
 
# Inicialización de los datos
 
lit 10		# ac: 10
store r0	# r0: 10
lit 3		# ac: 3
store r1	# r1: 3
lit 0		# ac: 0
 
 
# Bucles
 
load r1		# ac: r1
dec		# ac: ac--
store r1	# r1: ac
cmpl 0		# comparar ac & 0
jmpe 23		# ac == 0 --> jmp 23
 
lit 10		# ac: 10
store r0	# r0: 10
 
load r2		# ac: r2
inc		# ac: ac++
store r2	# r2: ac
load r0		# ac: r0
dec		# ac: ac--
store r0	# r0: ac
lit 0		# ac: 0
cmpr r0		# comparar ac & r0
jmpl 13		# ac < r0 --> jmp 13
jmp 6		# jmp 6
 
lit 0		# ac: 0
store r1	# r1: 0
 
halt		# stop

char codigo[] = {0x01, 0x0A, 0x03, 0x00, 0x01,
					   0x03, 0x03, 0x01, 0x01, 0x00,			   
					   0x02, 0x01, 0x05, 0x03, 0x01, 0x0A, 0x00,
					   0x0D, 0x29,
					   0x01, 0x0A, 0x03, 0x00, 0x02, 0x02, 0x04,
					   0x03, 0x02, 0x02, 0x00, 0x05, 0x03, 0x00,
					   0x01, 0x00, 0x0B, 0x00, 0x0D, 23, 0x0C,
					   10, 0x01, 0x00, 0x03, 0x01, 0x00};

---

Espero opiniones, críticas y sus comentarios

Supongamos que yo tengo la siguiente matriz:

char codigo[] = {0x00, 0xFF, 0x01, 0x03, 0x01, 0xFF, 0xFF, 0x00};

Con esta matriz se podrian hacer muchas cosas, desde interpretarla, hasta leer numeros. Mi pregunta:

En la posición 5 (recordar que empieza desde 0) y en la 6 hay 0xFF. Perfectamente podria poner en numero entero como 256, 256. Pero mi cuestion es: ¿Cómo puedo leer esos dos 0xFF, para que me queden como un 0xFFFF (tamaño de short int). Para que me entiendan, si hubiera: 0x4F, 0x33; quedaria: 0x4F33.

Se me ocurrieron varias opciones como: (0x4F << 2) &  0x33, pero ningun me funciona. ¿Podrían ayudarme?

Llevo ya desarroyando una máquina virtual largo tiempo, pero no tengo mucho tiempo, estoy con otros proyectos más importantes. Las funciones actuales (no creo que implemente alguna función más, sólo características y ampliaciones):

---

0x00	halt	detiene el cpu
0x01	lit	cargar en acumulador un valor inmediato
0x02	load	cargar en acumulador valor de un registro
0x03	store	almacenar valor acumulador en un registro
0x04	inc	incrementar por 1 el acumulador
0x05	dec	decrementar por 1 el acumulador
0x06	pushl	poner en pila un valor inmediato
0x07	pushr	poner en pila valor de un registro
0x08	pop	eliminar 'cima de pila' (tos)
0x09	loadt	almacenar valor retorno de pop en acumulador
0x0A	cmpl	comparar acumulador con valor inmediado. establece flag
0x0B	cmpr	comparar acumulador con valor registro. establece flag
0x0C	jmp	saltar a direccion de codigo (inicio == 0x00)
0x0D	jmpl	saltar a direccion de codigo si flag == 1 ( < )
0x0E	jmpe	saltar a direccion de codigo si flag == 2 ( = )
0x0F	jmpg	saltar a direccion de codigo si flag == 3 ( > )

---

No es un juego de instrucciones completo ni facil de usar, pero teoricamente cualquier otra operación se puede hacer con esas instrucciones, de echo, hice una operación de multiplicar dos números (30 * 3):

#========================================
# CALCULAR MULTIPLICACION DE DOS NUMEROS
#========================================
# Utilizando tres registros se
# pueden hacer funciones de multiplicación
# de números.
#========================================
 
# Inicialización de los datos
 
lit 10		# ac: 10
store r0	# r0: 10
lit 3		# ac: 3
store r1	# r1: 3
lit 0		# ac: 0
 
 
# Bucles
 
load r1	# ac: r1
dec		# ac: ac--
store r1	# r1: ac
cmpl 0	# comparar ac & 0
jmpe 23	# ac == 0 --> jmp 23
 
lit 10		# ac: 10
store r0	# r0: 10
 
load r2	# ac: r2
inc		# ac: ac++
store r2	# r2: ac
load r0	# ac: r0
dec		# ac: ac--
store r0	# r0: ac
lit 0		# ac: 0
cmpr r0	# comparar ac & r0
jmpl 13	# ac < r0 --> jmp 13
jmp 6	# jmp 6
 
lit 0		# ac: 0
store r1	# r1: 0
 
halt		# stop

A la hora de ser compilado para la máquina virtual, queda una matriz como:

char codigo[] = {
0x01, 0x0A, 0x03, 0x00, 0x01,0x03, 0x03, 0x01, 0x01, 0x00,
0x02, 0x01, 0x05, 0x03, 0x01, 0x0A, 0x00, 0x0D, 0x29,
0x01, 0x0A, 0x03, 0x00, 0x02, 0x02, 0x04, 0x03, 0x02, 0x02,
0x00, 0x05, 0x03, 0x00, 0x01, 0x00, 0x0B, 0x00, 0x0D, 23,
0x0C, 10, 0x01, 0x00, 0x03, 0x01, 0x00};

Cuya alternativa en código C:

int num1, num2 = 3;
int mult = 0;
 
for (; num2 > 0; num2--) {
	for(num1 = 10; num1 > 0; num1--) {
		mult++;
	}
}

---

Pueden si quieres crear sus propios algoritmos y postearlos en este mensaje, me ayudaría mucho, estoy intentando implementar "funciones externas", un archivo que incluya funciones para simplificar el trabajo. Esto es una multiplicación simple, seguramente se puede hacer optimizable y/o más corta, cualquier código que quieran crear utilizando esas funciones me ayudaria para probar la máquina virtual.

En aproximadamente 2 semanas espero publicar el código fuente completo... no me gusta sacar 100 versiones para una aplicacion!

Saludos

Supongamos por un momento que debes hacer un programa que calcule, lo más exactamente posible, una media, o cálculos, que de seguro, tendrán decimales. Sólo hay una pega, no puedes usar el tipo float bajo ningún concepto.

Lo mejor para este ejercicio sería crear un archivo de cabezera que incluya estructura para crear tu propio tipo float basandote en tipos enteros. Hacer eso es muy facil:

typedef struct _real {
        int entero;
        unsigned long int decimal;
} real_t;
 

Pero se deben crear tambien unas funciones que nos permita actuar con sencillez, como si de un tipo entero se tratase. Puedes empezar por estas funciones:

real_t declarar_real(int entero, unsigned long int decimal) {
    real_t real;    
 
    real.entero = entero;
    real.decimal = decimal;
 
    return real;
}
 
#define mostrar_real(a) printf("%d.%u", a.entero, a.decimal)
 

Lo que se pide en este ejercicio, para quienes quieran hacerlo para practicar sus conocimientos:
Crear funciones de suma y resta de numeros tipo real, al igual que funciones de multiplicación y división.
Si has echo lo anterior, prueba a modificar la estructura para que admita un número ilimitado de decimales (podrías hacerlo con una matriz dinámica).

Me gustaría que me diesen alguna opinión acerca de las implementaciones actuales y en el apartado 'para hacer' las ideas que tengo. La máquina virtual está programada y es rápida. Usa memoria dinámica para el uso de registros y la pila. Pronto intentaré implementar para el uso de API y añadir funcionalidades propias sin modificar código interno.

Expecificaciones del lenguaje:
Se trata de un microlenguaje de programación ensamblador orientado al uso de pila, registros y operaciones aritméticas. Esta diseñado con el mero propósito de aprender.

Dispone de 8 registros (r0-r7)(tipo entero), elegidos así porque me parece un número de registros adecuado. No admite cadenas de caracteres ni números reales. Es un lenguaje semicompilado, es decir, sus intrucciones son transmitidas a opcodes que son emulados por una máquina virtual (actualmente, la
máquina virtual ya está en una buena fase de desarrollo).

Algunas especificaciones técnicas del lenguaje:
   · Debe respetarse el orden de parámetros
   · Los registros son numerados desde 0 a 7, indicando que es un registro con la letra 'r' precediendo al número.
   · Para definir el inicio del programa debera utilizarse la etiqueta %main% precedida de las intrucciones.
   · Para definir el fin del programa debera utilizarse la etiqueta %end main%
   · Para definir una funcion común (no implementado) deberá utilizarse la etiqueta %nombredefuncion,parametro1,param...% finalizando esta con %end nombredefuncion%
   · Pueden incluirse comentarios en el código con ' y '= ='.
   · Cada línea tendrá como máximo una función
   · Pueden definirse 'cotas' de código para hacer el código más pequeño, compartiendo biblioteca que pueden ser incluidas en el código con %include archivo.mvm%. Se dispondrá de version estándar  de algunas implementaciones para agilizar el uso y ampliar las funciones con el uso de API.

Función 'setr' - Establece el valor a un registro:
   setr [r0-r7] num1      ' Uso normal

Función 'add' - Función con la capacidad de sumar 2 enteros y guardar la operación en el registro indicado:
   add [r0-r7] num1,num2   ' Uso normal
   
Función 'addr' - Suma 2 enteros, uno de ellos dado por el valor de un registro. Con las funciones add y addr pueden hacerse todas las operaciones de suma desde sumar dos registros hasta sumar registro con datos de la pila:
   addr [r0-r7] rX,rX      ' Uso normal
   
Función 'neg' - Niega el valor de un registro dado:
   neg [r0-r7]            ' Uso normal
   
El equivalente a la función 'sub' se puede utilizar conjuntamente con 'addr' y 'neg':
   '= Queremos restar r1 - r0 y guardar valor en r3 ='
   neg r0
   addr r3 r1 r0
   
Función 'mult' - Multiplica 2 enteros y guarda la operación en el registro dado:
   mult [r0-r7] num1,num2   ' Uso normal
   
Función 'multr' - Multiplica el valor de 2 registros y guarda la  operación en el registro dado:
   multr [r0-r7] rX,rX      ' Uso normal
   
Función 'push' - Pone el valor de un registro en pila:
   push [r0-r7]         ' Uso normal
   
Función 'pop' - Elimina el tos:
   pop                  ' Uso normal

Función 'inrp' - Intercambia el valor de un registro y del tos:
   inrp [r0-r7]         ' Uso normal

El equivalente a 'inrr' (intercambiar dos registros, mov), puede hacerse con funciones ya descritas:
   '= Queremos intercambiar r0 y r1. Vamos a suponer que todos los
   registros tienen valores que deben ser guardados. ='
   push r0
   inrp r1
   inrp r0
   pop

Otra utilidad que tiene las funciones anteriores, no se necesita de función 'clonr' (clonar valor de un registro en otro), ya que, esta podria hacerse de muchas otras maneras con inrp o addr.

Función 'cmp' - Comparar si el valor de un registro y un valor proporcionado son iguales, mayor, menor (con respecto al registro):
   cmp [r0-r7]   num1      ' Uso normal

Función 'cmpr' - Comparar si el valor de dos registros son iguales, mayor, o menor (con respecto al primer registro):
   cmpr [r0-r7] [r0-r7]   ' Uso normal

Para hacer:
Cambiar la forma de analizar las funciones, para evitar usar funciones clonadas para operar con registros (add, addr, mult, multr...); Así, se podrá operar con los registros de una forma más fácil y comoda.
Añadir funciones condicionales, uso de cadenas, operaciones con cadenas.
Ampliar numero de funciones aritméticas (shl, shr, xor, div, mod...).

Buenas a todos, inicio un nuevo POST para pedirles ayuda sobre la programación de un analizador léxico-sintáctico. No entiendo los códigos que vi por ahí, o si los entiendo, son demasiados complejos para implementarlos y hacer una adaptación.

Les pondré un ejemplo si no entienden lo que quiero conseguir. Supongamos un fichero de texto como el que sigue:

var
    int a, b, c;
    string d, e, f;
begin
    print("hola")
end

El desglosamiento del programa podría seguir un arbol como:

Declarar variables
   |-a como entero
   |-b como entero
   |-c como entero
   |-d como cadena
   |-e como cadena
   |-f como cadena
Iniciar ejecucion
   |- llamar funcion print con argumento hola como cadena
Fin ejecucion

Y que eso me genere unos ciertos opcodes, (no es necesario que el programa genere el arbol anterior), por ejemplo podria ser:
 0x00 a (declarar int a), 0x00 b (declarar int b) ... 0x01 d (declarar string d) ... 0x02 "hola" (llamar funcion print con argumento hola).

No se como implementar esto en C. ¿Alguien puede ayudarme?

Saludos,
   Miky Gonzalez

Supongamos por un momento el siguiente código:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//#include <inttypes.h>
 
/* MVM - Estructura de la MV */
typedef struct CPU {
	unsigned int inst_pointer;
	unsigned char *memoria;
} cpu_t;
 
cpu_t *crear_cpu(unsigned char *memoria) {
	if(!memoria) return NULL;
	cpu_t *cpu_init = malloc(sizeof(*cpu_init));
	cpu_init->inst_pointer = 0;
        cpu_init->memoria = memoria;
 
	return cpu_init;
}
 
void borrar_cpu(cpu_t *cpu) {
	if(!cpu) return;
	//void *datos = (void *)((uintptr_t)cpu);
	//free(datos);
	free(cpu);
}
 
int main(int argc, char *argv[]) {
	/* Inicializar datos y comprobar argumentos */
	if(argc < 2) {
		printf("Uso: %s <archivo>\n", argv[0]);
		return 0;
	}
	unsigned int codigo_volumen = 100;
	/* Reservar el espacio necesario para almacenar 
	 * el código en memoria. Si existe, copiarlo. */
	unsigned char *codigo = (unsigned char *)malloc(codigo_volumen);
	if(!fread(codigo, 1, codigo_volumen, ARCHIVO)) {
		fclose(codigo_archivo);
		return 0;
	} else fclose(codigo_archivo);
 
	cpu_t *cpu = crear_cpu(codigo);
	if(!cpu) return 0;
 
	borrar_cpu(cpu);
	free(codigo);
 
	return 0;
}
 

Faltan muchas parte del código, pero está lo esencial para mi cuestión. Explico un poco el funcionamiento:
Es una máquina virtual (¿dificil de saber?, no creo xD), en la que leo un archivo, calculo el tamaño, creo memoria dinamica para almacenar el contenido del archivo con malloc y fwrite respectivamente. Creo una variable con tipo estructura de la CPU de la MV, llamo a la funcion que me crea la CPU y le asigna el puntero. Despues libero la memoria del codigo (supuestamenta) y la de la CPU creada con la funcion crear_cpu, a través de la función borrar_cpu.
Creo que estoy utilizando mal, o los punteros, o el uso de free(). No se porqué, ni dónde, ni cómo hacerlo bien. El programa funciona correctamente, pero creo que hay fugas de memoria. ¿Podrían solventar mi problema?.

Voy a ir directo: tengo una función en C que me provoca un fallo de segmentación. He revisado y creo que los punteros están bien colocados y no devería de acceder a recursos de memoria no-accesibles.

void eliminar_espacios(char *contenido_linea) {
	char *cadena_temporal = (char *)malloc(255);
 
	while(*contenido_linea) {
		if((*contenido_linea != 32) && (*contenido_linea != '\t')) {
			contenido_linea++;
		} else {
			*cadena_temporal = *contenido_linea;
			cadena_temporal++;
		}
	}
 
	return (void)contenido_linea;
}
 

Elimina los espacios de una cadena.

Saludos!

Hace aproximadamente un par de semánas (estamos hablando de principio de marzo) publiqué el código fuente de una máquina virtual con un par de funciones.
Actualicé la máquina y tiene un juego de instrucciones como sigue:

halt    Detener la máquina virtual
setr    Establecer un valor inmediato en un registro
push    Almacena en la pila el valor de un registro
pop    Elimina el TOS (primer elemento de pila)
move    Intercambia los valores entre el TOS y un registro
sum    Suma el valor de un registro y otro, el valor se almacena en el primer registro
div    Divide el valor de un registro y otro, el valor se almacena en el primer registro
mod    Divide el valor de un registro y otro, el valor del resto de división se almacena en el primer registro
mult    Multiplica el valor de un registro y otro, el valor se almacena en el primer registro
not    Niega un elemento
xor    Operación OR condicional con dos registros. El valor se almacena en el primer registro
shl    Mueve los bits de un registro hacia la izquierda un numero de veces como marque el segundo registro.
shr    Mueve los bits de un registro hacia la derecha un numero de veces como marque el segundo registro.
ife    Si los dos registros especificados son iguales, ejecuta la siguiente accion. En caso contrario la salta.
goto    Establece el 'ip' al valor inmediato dado.

El código fuente puede obtenerse de aquí

Unos ejemplos tambien pueden obtener desde aquí (con los opcodes correspondientes)

Un saludo, espero que les sirve de alguna utilidad. Un ejemplo de su uso podría ser por ejemplo para utilizar en algoritmo de cifrado, es mucho más difícil saber de donde sale un dato si este se está ejecutando virtualmente.

Puede obtener más información en: artículo

Haber, no sabía como poner esto hexactamente, así que pense en un nombre:


Creo que no hace falta explicar mucho, es un dumpeador hexadecimal para convertir cualquier archivo a variable del tipo char en C. En otras palabras, convierte:

#include <stdio.h>
 
double factorial(short int numero) {
    int pred = 0;
    double tmp = numero;
    for (pred = --numero; pred > 1; --pred)
        tmp *= pred;
    return tmp;
}
 
int main(void) {
    double factor87 = factorial(87);
    printf("Factorial de 87: %.20lg", factor87);
    getchar();   
    return 0;
}

En esto:

char hexdump2c[] = {
0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x73, 0x74, 0x64, 0x69, 0x6f, 0x2e, 0x68, 0x3e, 
0x0d, 0x0a, 0x0d, 0x0a, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x69, 
0x61, 0x6c, 0x28, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x20, 0x69, 0x6e, 0x74, 0x20, 0x6e, 0x75, 0x6d, 0x65, 0x72, 
0x6f, 0x29, 0x20, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6e, 0x74, 0x20, 0x70, 0x72, 0x65, 0x64, 
0x20, 0x3d, 0x20, 0x30, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x20, 
0x74, 0x6d, 0x70, 0x20, 0x3d, 0x20, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x6f, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 
0x20, 0x66, 0x6f, 0x72, 0x20, 0x28, 0x70, 0x72, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x2d, 0x2d, 0x6e, 0x75, 0x6d, 
0x65, 0x72, 0x6f, 0x3b, 0x20, 0x70, 0x72, 0x65, 0x64, 0x20, 0x3e, 0x20, 0x31, 0x3b, 0x20, 0x2d, 0x2d, 0x70, 
0x72, 0x65, 0x64, 0x29, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x74, 0x6d, 0x70, 0x20, 
0x2a, 0x3d, 0x20, 0x70, 0x72, 0x65, 0x64, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 
0x72, 0x6e, 0x20, 0x74, 0x6d, 0x70, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a, 0x0d, 0x0a, 0x69, 0x6e, 0x74, 0x20, 
0x6d, 0x61, 0x69, 0x6e, 0x28, 0x76, 0x6f, 0x69, 0x64, 0x29, 0x20, 0x7b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 
0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x38, 0x37, 0x20, 0x3d, 0x20, 
0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x6c, 0x28, 0x38, 0x37, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 
0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x66, 0x28, 0x22, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x61, 
0x6c, 0x20, 0x64, 0x65, 0x20, 0x38, 0x37, 0x3a, 0x20, 0x25, 0x2e, 0x32, 0x30, 0x6c, 0x67, 0x22, 0x2c, 0x20, 
0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x38, 0x37, 0x29, 0x3b, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x67, 0x65, 
0x74, 0x63, 0x68, 0x61, 0x72, 0x28, 0x29, 0x3b, 0x20, 0x20, 0x20, 0x0d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 
0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x30, 0x3b, 0x0d, 0x0a, 0x7d, 0x0d, 0x0a};

El código fuente del programa es:

/* Simple dumpeador de archivos a hexadecimal y guardar en C
 * http://mikygonzalez.16mb.com
*/
 
#include <stdio.h>
 
#define TAM_HEXCODE 18
 
/*! Función principal hexdump */
void hexdump(FILE *archivo_fd) {
	unsigned short int bucle_i;
	char caracter_actual = '\0';
	fseek(archivo_fd, 0, SEEK_SET);
 
	while(!feof(archivo_fd)) {
		for(bucle_i = 0; bucle_i < TAM_HEXCODE; bucle_i++) {
			caracter_actual = fgetc(archivo_fd);
			if(caracter_actual == EOF)
				return (void) 0;
			printf("0x%.2x, ", caracter_actual);
		}
		printf("\n");
	}
}
 
int main(int argc, char *argv[]) {
	FILE *archivo_fd;
 
	if(argc < 2)
		return 1;
	if(!(archivo_fd = fopen(argv[1], "rb")))
		return 1;
 
	printf("char hexdump2c[] = {\n");
	hexdump(archivo_fd);
	printf("\b\b};\n");
 
	return 0;
}

También pueden encontrarse este y otros programas en: http://pastes.mikygonzalez.16mb.com/?ad2cea935c65385a#c0bI9LQ9BD6f8snTLpklw/LgzXRnOEs6lJHJWqbbb9c= o en mi pagina personal (en la firma).

Saludos