typedef struct _vectf {
	float *data;
	int size;
} vectf;
 
int init_vectorf(vectf *vectorf, int capacity) {
	vectorf->size = capacity * sizeof(float);
	vectorf->data = malloc(vectorf->size);
	if(!vectorf->data)
		return 0;
 
	printf("[*] Inicializado vectorf de tamano: %d (%d elementos).", vectorf->size, vectorf->size / (int)sizeof(float));
 
	return 1;
}

typedef struct _vectf {
	float *data;
	int capacity;
	int size;
} vectf;
 
int init_vectorf(vectf *vectorf, int capacity) {
	vectorf->capacity = capacity;
	vectorf->size = capacity * sizeof(float);
	vectorf->data = malloc(vectorf->size);
	if(!vectorf->data)
		return 0;
 
	printf("[*] Inicializado vectorf de tamano: %d (%d elementos).", vectorf->size, capacity);
 
	return 1;
}

typedef struct _vectf {
	float *data;
	int cap; 
} vectf;

vectf v;

int init_vectorf(vectf *vectorf, int capacity) {
	vectorf->data = malloc(capacity * sizeof(float));
	if(!vectorf->data)
		return 0;
 
	vectorf->cap = sizeof(vectorf->data) / sizeof(vectorf->data[0]); 
	//vectorf->cap = capacity;
	printf("sizeof(float) = %ld\n", sizeof(float));
	printf("Inicializado vectorf de tamano: %d (%d elementos).", (int)sizeof(vectorf->data), sizeof(vectorf->data) / sizeof(vectorf->data[0]));
 
	return 1;
}

init_vectorf(&vectorf, 3);

vectorf->cap = sizeof(vectorf->data) / sizeof(vectorf->data[0]); 

mikygonzalez@public_gpg ~/ $ Inicializado vectorf de tamano: 8 (2 elementos).

Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Gilisoft-usb-lock\configure]
"datP"=hex:9e,00

Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SOFTWARE\Gilisoft-usb-lock\configure]
"datP"=hex:9e,00

#include <gtk/gtk.h>
 
int main(int argc, char *argv[]) {
	/*! Los widgets que usaremos */
	GtkWidget *win = NULL;		// Ventana
	GtkWidget *close = NULL;	// Botón cerrar
 
	/*! Inicializar GTK+ */
	g_log_set_handler("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc)gtk_false, NULL);
	gtk_init(&argc, &argv);
	g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
 
	/*! Hacer la ventana */
	win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_container_set_border_width(GTK_CONTAINER(win), 10);
	gtk_widget_realize(win);
 
	/*! Botón que ayudará a cerrar la ventana */
	close = gtk_button_new_with_label("CERRAR VENTANA");
	gtk_container_add(GTK_CONTAINER(win), close);
 
	/*! Devoluciones de llamadas (Callbacks) */
	g_signal_connect((gpointer)close, "clicked", G_CALLBACK(gtk_main_quit), NULL);	// Botón cerrar
	g_signal_connect((gpointer)win, "destroy", G_CALLBACK(gtk_main_quit), NULL);	// Ventana
 
	/*! Entrar en bucle principal */
	gtk_widget_show_all(win);
	gtk_main();
	return 0;
}
 

char lista_instrucciones[NUM_INSTR][10] = {
	{"PRINT"},	
	{"SUM"},
	{"EXIT"}
};
 
char *codigo = "PRINT BASURA!", *codigo2 = "EXIT TRASH";
 
void identificador_cadena(unsigned char *codigo) {
	unsigned short int pos_buffer = 0;
	char *buffer = (char *)malloc(1 * sizeof(char));
 
	while(saber_letra(codigo[pos])) {
		buffer[pos_buffer] = codigo[pos];
		pos++;
		pos_buffer++;
		buffer = (char *)realloc(buffer, (pos_buffer + 1) * sizeof(char));
	}
 
	buffer[pos_buffer] = '\0';
 
	// Reutilizar variable pos_buffer
	for(pos_buffer = 0; pos_buffer < NUM_INSTR; pos_buffer++)
		if(!strcmp(buffer, lista_instrucciones[pos_buffer]))
			printf("Encontrado %s en %s\n", lista_instrucciones[pos_buffer], buffer);			
 
	free(buffer);
	return;
}
 

Encontrado PRINT en PRINT
Encontrado EXIT en EXIT

Encontrado SUM en PRINT
Encontrado EXIT en PRINT
Encontrado PRINT en EXIT
Encontrado SUM en EXIT

#include <stdio.h>
 
int m = 1711276033, N = 1, t[1 << 25] = { 2 }, a, *p, i, e = 39717691, s, c, U = 1;
 
void g(int d, int h) {
	for(i = s; i < 1 << 24; i *= 2)
		d = d * 1LL * d % m;
	for(p = t; p < t + N; p += s)
		for(i = s, c = 1; i; i--)
			a = p[s] * (h ? c : 1LL) % m, p[s] = (m * 1U + *p - a) * (h ? 1LL : c) % m, *p = (a * 1U + *p) % m, p++, c = c * 1LL * d % m;
}
 
int main() {
	while(e /= 2) {
		N *= 2;
		U = U * 1LL * (m + 1) / 2 % m;
		for(s = N; s /= 2;)
			g(40, 0);
		for(p = t; p < t + N; p++)
			*p = *p * 1LL ** p % m * U % m;
		for(s = 1; s < N; s *= 2)
			g(983983719, 1);
		for(a = 0, p = t; p < t + N;)
			a += *p << (e & 1), *p++ = a % 10, a /= 10;
	}
	while(!*--p);
	for(t[0]--; p >= t;)
		putchar(48 + *p--);
 
	return 0;
}
 

/*! Ejemplo de lector de archivo */
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#define NUM_INSTR 2
 
/*! Declaración de variables locales */
enum {lex_PARI = '(', lex_PARD = ')', lex_LLAI = '{', lex_LLAD = '}'};
 
unsigned short int pos = 0x00;
unsigned int codigo_volumen;
char lista_instrucciones[NUM_INSTR][10] = {
	{"PRINT"},	
	{"EXIT"}
};
 
void siguiente_lexema(unsigned char *codigo);
int saber_letra(char caracter);
 
void buscar_caracter(char caracter, unsigned char *codigo) {
	pos++;
	while((codigo[pos] != caracter) && (pos < codigo_volumen))
		siguiente_lexema(codigo);
 
	if(pos == codigo_volumen)
		printf("Se esperaba '%c'", caracter);
}
 
/*
 * TODO: Identificar palabra reservada ó símbolo
*/
// modo == 0 (si cadena)
// modo == 1 (si entero)
void identificador_cadena(unsigned char *codigo) {
	unsigned short int pos_buffer = 0;
	char *buffer = (char *)malloc(1 * sizeof(char));
 
	while(saber_letra(codigo[pos])) {
		buffer[pos_buffer] = codigo[pos];
		pos++;
		pos_buffer++;
		buffer = (char *)realloc(buffer, (pos_buffer + 1) * sizeof(char));
	}
 
	// Reutilizar variable pos_buffer
	for(pos_buffer = 0; pos_buffer < NUM_INSTR; pos_buffer++)
		 if(strcmp(buffer, lista_instrucciones[pos_buffer]))
			printf("Encontrado %s en %s", lista_instrucciones[pos_buffer], buffer);
 
	free(buffer);
	return;
}
 
int saber_letra(char caracter) {
	return ((caracter >= 'A') && (caracter <= 'Z')) || ((caracter >= 'a') && (caracter <= 'z'));
}
 
int saber_numero(char caracter) {
	return (caracter >= '0') && (caracter <= '9');
}
 
void siguiente_lexema(unsigned char *codigo) {
	switch(codigo[pos]) {
		case lex_PARI:
			printf("Encontrado: %c\n", lex_PARI);
			buscar_caracter(lex_PARD, codigo);
			break;
		case lex_LLAI:
			printf("Encontrado: %c\n", lex_LLAI);
			buscar_caracter(lex_LLAD, codigo);
			break;
		default:
			if(saber_letra(codigo[pos]))
				identificador_cadena(codigo);
			else if(saber_numero(codigo[pos]))
				//identificador(codigo, 1);
				;
			/*
			 * TODO: Mostrar error. Ignorar espacios, salto de línea y tabulador
			*/
			else
				;
			break;
	}
 
	pos++;
	return;
}
 
int main(int argc, char **argv) {
	if(argc < 2) {
		printf("Uso: %s <archivo>\n", argv[0]);
		return 0;
	}
	FILE *codigo_archivo = fopen(argv[1], "r");
	if(!codigo_archivo) {
		printf("[ASM] Error al leer el archivo %s\n", argv[1]);
		return 0;
	}
 
	/* Calcular tamaño (volumen) del código */
	fseek(codigo_archivo, 0, SEEK_END);
	codigo_volumen = ftell(codigo_archivo);
	rewind(codigo_archivo);
	if(!codigo_volumen) {
		printf("[ASM] No hay instrucciones...\n");
		fclose(codigo_archivo);
		return 0;
	}
 
	/* 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, codigo_archivo)) {
		printf("[ASM] Error en lectura de archivo...\n");
		fclose(codigo_archivo);
		return 0;
	} else fclose(codigo_archivo);
 
	while(pos < codigo_volumen)
		siguiente_lexema(codigo);
 
	return 0;
}
 

/*! Ejemplo de lector de archivo */
 
#include <stdio.h>
#include <stdlib.h>
 
/*! Declaración de variables locales */
enum {lex_PARI = '(', lex_PARD = ')', lex_LLAI = '{', lex_LLAD = '}'};
unsigned short int pos = 0x00;
unsigned int codigo_volumen;
unsigned char *codigo;
FILE *codigo_archivo;
 
void siguiente_lexema(unsigned char *codigo);
 
void buscar_caracter(char caracter) {
	while((caracter != codigo[pos]) && (pos < codigo_volumen)) {
		siguiente_lexema(codigo);
		pos++;
	}
	if(pos == codigo_volumen)
		printf("Se esperaba '%c'", caracter);
}
 
// modo == 0 (si cadena)
// modo == 1 (si entero)
void identificador(unsigned char *codigo, char modo) {
 
	return;
}
 
int saber_letra(char caracter) {
	return (((caracter >= 'A') && (caracter <= 'Z')) || ((caracter >= 'a') && (caracter <= 'z')));
}
 
int saber_numero(char caracter) {
	return ((caracter >= '0') && (caracter <= '9'));
}
 
void siguiente_lexema(unsigned char *codigo) {
	switch(codigo[pos]) {
		case lex_PARI:
			printf("Encontrado: %c\n", lex_PARI);
			buscar_caracter(lex_PARD);
			break;
		case lex_LLAI:
			printf("Encontrado: %c\n", lex_LLAI);
			buscar_caracter(lex_LLAD);
			break;
		default:
			if(saber_letra(codigo[pos]))
				identificador(codigo, 0);
			else if(saber_numero(codigo[pos]))
				identificador(codigo, 1);
			/*
			 * TODO: Mostrar error. Ignorar espacios, salto de línea y tabulador
			*/
			else
				;
			break;
	}
 
	return;
}
 
int main(int argc, char **argv) {
	if(argc < 2) {
		printf("Uso: %s <archivo>\n", argv[0]);
		return 0;
	}
	codigo_archivo = fopen(argv[1], "r");
	if(!codigo_archivo) {
		printf("[ASM] Error al leer el archivo %s\n", argv[1]);
		return 0;
	}
 
	/* Calcular tamaño (volumen) del código */
	fseek(codigo_archivo, 0, SEEK_END);
	codigo_volumen = ftell(codigo_archivo);
	rewind(codigo_archivo);
	if(!codigo_volumen) {
		printf("[ASM] No hay instrucciones...\n");
		fclose(codigo_archivo);
		return 0;
	}
 
	/* Reservar el espacio necesario para almacenar 
	 * el código en memoria. Si existe, copiarlo. */
	codigo = (unsigned char *)malloc(codigo_volumen);
	if(!fread(codigo, 1, codigo_volumen, codigo_archivo)) {
		printf("[ASM] Error en lectura de archivo...\n");
		fclose(codigo_archivo);
		return 0;
	} else fclose(codigo_archivo);
 
	while(pos < codigo_volumen) {
		siguiente_lexema(codigo);
		pos++;
	}
 
	return 0;
}
 

{
{
{
( {} )( } } }