Mensajes

Muchas gracias por la ayuda, alfinal el pensar si decidir sobre el rendimiento sobre la estabilidad es cosa del programador.

Marco el tema como resuelto.

Saludos.

@ivancea96:

Entonces, una posible solución podría ser (no explicada, pero se entiende bien):

Código (c) [Seleccionar] Expandir

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;
}

O ahorrando a la larga algunas operaciones:

Código (c) [Seleccionar] Expandir

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;
}

Para el uso más cómodo de un programa en la creación de un simulador físico que requiere el uso de muchos vectores se me ha ocurrido crear una libreria para el manejo de los vectores. Comienzo definiendo la siguiente estructura:

Código (c) [Seleccionar] Expandir

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

Entonces para la creación del vector uso:

Código (c) [Seleccionar] Expandir

vectf v;

Y creo una función que inicialice el vector (reservar memoria y ajustar elementos):

Código (c) [Seleccionar] Expandir

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;
}

En este paso se encuentra mi problema. Explicaré la idea del código para un mejor entendimiento:
1. Se reserva memoria para (n_elementos * tamaño_dato), esto es, si yo declaro:

Código (c) [Seleccionar] Expandir

init_vectorf(&vectorf, 3);

el cálculo sería: (3 * sizeof(float)), es decir, 3 elementos * 4 bytes = 12 bytes.

Cuando se hace la operación:

Código (c) [Seleccionar] Expandir

vectorf->cap = sizeof(vectorf->data) / sizeof(vectorf->data[0]); la capacidad se establece a 3, como debería: memoria_total / tamaño_dato = 12 bytes / 4 bytes = 3 elementos.

El error viene que justamente despues al mostrarse la información de inicialización del vector escribe el siguiente mensaje en pantalla:

Código (bash) [Seleccionar] Expandir

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

¿Alguien puede explicar porqué no me devuelve tamaño 12, 3 elementos?. Seguramente sea un error con los punteros ó el tamaño de datos, pero no soy capaz de localizarlo.

Saludos,
MikyGonzalez

[Gilisoft Usb Lock]

Gilisoft Usb Lock es un programa que nos permite entre muchas otras cosas bloquear el acceso USB y páginas web.

Su utilización es sencilla y tiene la posibilidad de introducir una contraseña de acceso para modificar sus configuraciones. Esta contraseña esta cifrada, y nosotros a traves del editor de registro podemos saber la contraseña (cifrada). No hace falta saber el algoritmo de cifrado, ya que cualquier valor que introduzcamos en el campo de contraseña equivale a un valor cifrado. A esto se le llama cifrado por diccionario (por ejemplo: a = 0x85, b = 0x86...). En esta situación se puede producir un ataque fácilmente porque el algoritmo de cifrado no determina ni la posición del carácter ni la longitud de la cadena.

Despues de ver el código del programa, se determina el siguiente diccionario:

Si es una contraseña larga y no merece buscar cual es el texto descifrado, podríamos sustituir todo el contenido por: 9e 00, equivalente a la contraseña "a" ('a'-'\0').

Una alternativa para ordenador que tienen eliminado/prohibido el uso del editor de registro, se puede utilizar el comando reg para interactuar con el registro; un ejemplo de su uso: reg import cambiar_clave_gilisoft.reg.

Para el uso con sistemas de 64Bits, el código a importar en registro sería como sigue:

Código (dos) [Seleccionar] Expandir

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

32 Bits:

Código (dos) [Seleccionar] Expandir

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

[CreateWindowEx]

Para crear una simple ventana (generalmente me gusta el código multiplataforma) te aconsejo usar GTK, versión 2 ó 3.

Un ejemplo de código que te podría servir, aunque necesitas documentarte:

Código (c) [Seleccionar] Expandir

#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;
}


También puedes crear tu propia ventana con la API nativa de windows haciendo uso de funciones como: CreateWindowEx, RegisterClass, ShowWindow.
Espero que te haya servido de ayuda, puedes encontrar documentos de interés en:

http://www.winprog.org/tutorial/start.html

La cosa estaba en poner los códigos de la manera más ofuscada posible 

Dado el siguiente código:

Código (c) [Seleccionar] Expandir

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;
}


Se espera que al pasar las variables codigo y codigo2 a la función identificador_cadena, esta imprima en pantalla:

Código [Seleccionar] Expandir

Encontrado PRINT en PRINT
Encontrado EXIT en EXIT

Pero en su lugar, imprime:

Código [Seleccionar] Expandir

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

¿Alguien podría determinar el error?, no entiendo porque esto sucede

Solo por interés, les dejo un código proveniente de una fuente web que les dejo más abajo:

Código (c) [Seleccionar] Expandir

#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;
}


[1] http://ijunkey.com/a-small-c-program-to-print-the-biggest-prime-number/

[rir3760]

Gracias por la ayuda, al final resultó ser un problema estúpido. No aumentaba la variable pos en un determinado caso: que los paréntesis sean escritos juntos.

Respecto al comentario de rir3760:

La falta de consistencia está solucionado. Si te preguntas el porqué paso código como parámetro se debe a que en un futuro implementaré hilos para hacer el proceso más rápido (analizar varios archivos al mismo tiempo). Utilizo funciones (podría hacerlo con un #define pero aumentaría tamaño del código) propias porque me han resultado ser más rápidas (linux).
Los mensajes de error prefiero especificarlos yo, para tener un control absoluto del sistema de errores que se produzcan en el programa.
La forma en la que tengo implementada el código no podría admitir el uso de fgetc() para leer el tamaño del archivo, a no ser que la lectura y el analizado se hagan de una forma atómica. No se producirá ningún error, porque carácteres como ' ', '\t', '\n', '\r'... serán descartados de análisis.

El código resultante:

Código (c) [Seleccionar] Expandir

/*! 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;
}


Estaba programando en C un ensamblador para programas de mi máquina virtual (decidí continuar un proyecto). Tengo el siguiente código:

Código (c) [Seleccionar] Expandir

/*! 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;
}


El problema está en que dado un archivo:

Código (ini) [Seleccionar] Expandir

{
{
{
( {} )( } } }


Entra en un bucle infinito. He revisado muchas veces el código pero no veo ningún error de direcciones, punteros... ¿Alguien puede determinar a causa de que?