Mensajes

Estamos jodidos... esto va de mal en peor. Al final sí que van a privatizar tanto internet que sólo unos pocos lo tendrán...

Muy bueno The Swash!
Ten por seguro que me lo voy a mirar bien y me será muy útil 

Un saludo!

Muchas gracias por los libros. Es una lástima que no traduzcan "The Art Of Assembly"... me gustaría leerlo cómodamente en mi idioma.

Saludos! 

Aquí dejo la versión casi completa, hasta reporte de nuevos fallos.

Código (C) [Seleccionar] Expandir


/* char **split(char *string, char *sep);
   Coded by Binary_Death on 30/6/2011
*/
#include <stdlib.h>
#include <stdio.h>
typedef struct {
        char **substring_ptr;
        int number_of_substrings;
} split_struct;
split_struct* split(char*,char*);
int _strlen(char*);
int _cmp(char*,char*,int);
int main() {
    split_struct *str;
    str = split("STRING1#DLM#STRING2#DLM#STRING3","#DLM#");
    for(int y=0;y<str->number_of_substrings;y++)
    {printf("%s\n", str->substring_ptr[y]);}
    getchar();
    return 0;
}
split_struct *split(char *string,char *sep) {
     split_struct *retvalue;
     retvalue = (split_struct*)malloc(sizeof(split_struct));
     int str_len=_strlen(string);
     int sep_len=_strlen(sep);
     int ptr_block=0, chr=0, bool_end=0;
     char **buffer = (char**)malloc(sizeof(char*));
     *buffer = (char*)malloc(sizeof(char*));**buffer=0;
     char *tok = (char*)malloc(sep_len*sizeof(char));
     for(int z=0;z<str_len;z++) {
             for(int n=0;n<sep_len&&!bool_end;n++)
             tok[n]=(z+n<str_len)?string[z+n]:bool_end=1;
             if(_cmp(tok,sep,sep_len)||bool_end) {
                                  buffer[ptr_block][chr++] = string[z];
                                  buffer[ptr_block] = (char*)realloc(buffer[ptr_block],chr*sizeof(char*));
                                  buffer[ptr_block][chr] = 0;
                                   } else {
                                          buffer = (char**)realloc(buffer,(++ptr_block+1)*sizeof(char*));
                                          buffer[ptr_block] = (char*)malloc(sizeof(char*));**(buffer+ptr_block)=0;
                                          chr=0;z+=sep_len-1;
                                   }                           
    }
free(tok);
retvalue->substring_ptr = buffer;
retvalue->number_of_substrings = ptr_block+1;
return retvalue;
}
int _strlen(char *pstr) {
    int i=0;
    while(*(pstr++)!='\0') i++;
    return i;
}
int _cmp(char *fstr,char *sstr, int len) {
    int bytes=0;
    while(bytes++<len) if(*(fstr++)!=*(sstr++)) return 1;
    return 0;
}


Esta vez devuelve un puntero a una estructura que contiene el array de cadenas y el número de cadenas obtenidas.

Saludos!

Recién ahora me di cuenta de un error que no sé de donde viene... ando ahí intentando descubrir  

Si intento con una cadena como:

"String1SEPAString1","SEPA"

Curiosamente, al imprimir array[1] sólo me muestra String, en vez de String1.
Y por cada carácter que aumento en el separador, un carácter menos que muestra de la String...

Gracias por los links, les echaré una leída  


EDIT: Ya le vi el error... miraré la mejor forma de corregirlo y lo edito en el primer post.

Una pregunta, BlackZeroX, ¿tú función es capaz de interpretar cadenas con un carácter nulo '\0' en medio? Es que sería necesario si se usa la función con ficheros binarios, y no sé como hacer que eso sea posible.

He hecho esta típica función en C...
Es digamos la primera versión así que debe de tener muchos errores, de hecho hasta me atrevería a decir que es cutre, pero en fin, aquí os la dejo:

Código (C) [Seleccionar] Expandir


/* char **split(char *string, char *sep);
   Coded by Binary_Death on 30/6/2011
*/
#include <stdlib.h>
#include <stdio.h>
char **split(char*,char*);
int _strlen(char*);
int _cmp(char*,char*,int);
int main() {
    char **array = split("STRING1#DLM#STRING2#DLM#STRING3","#DLM#");
    for(int y=0;y<3;y++) printf("%s\n", array[y]);
    getchar();
    return 0;
}
char **split(char *string,char *sep) {
     int str_len=_strlen(string);
     int sep_len=_strlen(sep);
     int ptr_block=0, chr=0, bool_end=0;
     char **buffer = (char**)malloc(sizeof(char*));
     *buffer = (char*)malloc(sizeof(char*));**buffer=0;
     char *tok = (char*)malloc(sep_len*sizeof(char));
     for(int z=0;z<str_len;z++) {
             for(int n=0;n<sep_len&&!bool_end;n++)
             {(str_len-(z+1)>=sep_len)?tok[n]=string[z+n]:bool_end=1;}
             if(_cmp(tok,sep,sep_len)||bool_end) {
                                  buffer[ptr_block][chr++] = string[z];
                                  buffer[ptr_block] = (char*)realloc(buffer[ptr_block],chr*sizeof(char*));
                                  buffer[ptr_block][chr] = 0;
                                   } else {
                                          buffer = (char**)realloc(buffer,(++ptr_block+1)*sizeof(char*));
                                          buffer[ptr_block] = (char*)malloc(sizeof(char*));
                                          chr=0;z+=sep_len-1;
                                   }                           
    }
free(tok);
return buffer;
}
int _strlen(char *pstr) {
    int i=0;
    while(*(pstr++)!='\0') i++;
    return i;
}
int _cmp(char *fstr,char *sstr, int len) {
    int bytes=0;
    while(bytes++<len) if(*(fstr++)!=*(sstr++)) return 1;
    return 0;
}


Agradecería que se me reportaran los errores y así mejorar  

Saludos!

EDITO: Ya esta arreglado! Igual seguro que tiene muchos errores más, ya se irán arreglando, yo soy paciente  

EDITO2: Segunda modificación, he reducido y optimizado muchísimo el código.

Bueno chicos...
A ver, me he leído el libro "Ensamblador para DOS, Linux y Windows", de Francisco Charte Ojeda.
La cosa es que vi el índice de "Guía Práctica del Lengua Ensamblador", del mismo autor, y vi que al menos aparentemente hay muchas cosas que no aparecen en el otro libro. Parece ser como una guía de referencia, y en ese caso me interesaría para ver más detalles que no se explican en el otro libro.

No es demasiado caro, pero aún así no es cuestión de gastar por gastar.
Alguien que tenga los dos, ¿podría decirme si vale la pena comprar la guía práctica habiendo leído el otro libro?

Gracias y saludos   

Mi segundo programa. Mi segundo día de estudio de asm  
Imagino que usé el método más espantoso para hacerlo... pero bueno, no se casi nada y es sólo mi segundo code de práctica... así que xD

Código (asm) [Seleccionar] Expandir


;;;;;;;;;;;;;;;;;
;String Reverse ;
;By Binary_Death;
;;;;;;;;;;;;;;;;;
segment Data
msg1 db 'Cadena a invertir: $'
msg2 db 'Cadena invertida: $'
string times 256 db ' '
char db ' $'
clf db 10,13,10,13,'$'
segment Stack stack
resb 256
StackEnd:
segment Code
..start:
mov ax, Stack
mov ss, ax
mov sp, StackEnd
mov ax, Data
mov ds, ax
mov ah,9h
mov dx,msg1
int 21h
xor bx,bx
SaveStr:
xor ah,ah
int 16h
cmp al,0Dh
je ShowStr
mov [string+bx],al
mov [char],al
mov dx,char
mov ah,9
int 21h
cmp bx,00FFh
je ShowStr
inc bx
jmp SaveStr
ShowStr:
mov ah,9h
mov dx,clf
int 21h
mov dx,msg2
int 21h
dec bx
LoopPos:
mov al,[string+bx]
mov [char],al
mov ah,9h
mov dx,char
int 21h
cmp bx,00h
je Exit
dec bx
jmp LoopPos
Exit:
xor ah,ah
int 16h
mov ah,4ch
int 21h


Agradecería que se me comentara cómo mejorar.

Saludos!

EDITO:

Bueno, en el tercer día de aprendizaje aprendí unas cuantas nuevas cosas. Así que mejoré esto...

Código (asm) [Seleccionar] Expandir


;;;;;;;;;;;;;;;;;
;;StrRev 16 bit;;
;;    NASM     ;;
;;Binary_Death ;;
;;;;;;;;;;;;;;;;;
segment data
MSG1 DB 'Cadena a Invertir: $'
MSG2 DB 'Cadena Invertida: $'
CRNL DB 10,13,'$'
BKSC DB 8,'$'
CHR1 DB ' $'
segment stck stack
resb 256
SpOffset:

segment code
..start:

;Asumimos segmentos
mov ax,data
mov ds,ax ;DS=Data
mov es,ax ;ES=Data

mov ax,stck
mov ss,ax ;SS=Stck
mov sp,SpOffset ;SP=Offset(SpOffset)

mov ah,9h
mov dx,MSG1
int 21h ;Mostramos MSG1 en pantalla

mov dx,0FFh
xor cx,cx
PushLoop:
xor ah,ah
int 16h ;Pedimos carácter por teclado
cmp al,9h ;Si CHR=BS
jz BackSpace ;jmp BackSpace
cmp al,0Dh ;Si chr=\CR
jz ShowStr ;jmp ShowStr
push ax ;Empujamos AH+AL(=00+Chr) a stack
mov [CHR1],al ;Guardamos carácter en memoria
mov ah,9h
mov dx,CHR1
int 21h ;Mostramos el carácter guardado
inc cx ;Incrementamos CX
dec dx ;Decrementamos DX
jnz PushLoop ;Si CX!=0 jmp PushLoop

ShowStr:
mov ah,9h
mov dx,CRNL ;Salto de línea
int 21h ;Efectuamos

PopLoop:
pop ax ;Recuperamos último CHR
mov [CHR1],al ;Lo guardamos en CHR1
mov ah,9h
mov dx,CHR1
int 21h ;Lo mostramos en pantalla
loop PopLoop ;Si CX!=0 jmp PopLoop

Exit:
xor ah,ah
int 16h ;Hacemos pausa
mov ah,4ch
int 21h ;Devolvemos control al OS

BackSpace:
mov ah,9h
mov dx,BKSC
int 21h
jmp PushLoop


A ver... leyendo un libro de asm, en la parte que habla de los registros del segmento y punteros de la pila, dice con palabras textuales esto:

Otros registros fundamentales, que deben configurarse al iniciar la ejecución de cualquier programa, son BP (Base Pointer) y SP (Stack Pointer). Ambos trabajan conjuntamente con el registro de segmento SS para definir la dirección base de la pila, que estaría en la dirección CS:BP, y la posición actual en la que están insertándose o recuperándose datos, que sería CS:SP. La pila es una estructura que crece en orden inverso, es decir, en principio CS contendrá el valor del final de pila, mientras que SP irá reduciéndose a medida que se inserten datos o incrementándose al extraerlos.

Hace referencia a SS como registro de segmento de pila. ¿No debería ser la dirección base indicada por SS:BP y el puntero a la posición actual de la pila indicado por SS:SP?
Digo, CS es el segmento de datos, y SS son 64kb de memoria aparte.

Así lo entendí yo. Y como me parece medio raro, quisiera saber si es un error de tipeo del libro (porque muchas veces esas cosas ocurren) o es que lo entendí mal xD.

Saludos!

Muchas gracias, entendido a la perfección =)