Newsgroup: it.comp.os.linux.development
Titolo: Blue Wave

Wave.
Fantastico! Cosa di bello, in particolare?
Sarebbe una figata, a prodotto finito, mettere il nome di Leonardo Serni
nei ringraziamenti. (-:
[ho messo xpost e f'up]
-- 
  _      ___ ____
 | | /| / (_)_  /
 | |/ |/ / / / /_	ANTI-SPAM WARNING:
 |__/|__/_/ /___/	the e-mail address is fake.
 
- Cosa c'e` nella struct sockaddr_in?
- Sa l'host... (i Troia)

Fantastico! Cosa di bello, in particolare?
Una funzione che legge i files .XTI, .FTI e .DAT e li processa uno per
uno. Avrei giurato di avere anche la funzione di esportazione... pero'
non riesco a ritrovarla. Faceva parte di un programmino, "Britannia" -
il nome e' dovuto a un orribile gioco di parole - che immagazzinava le
basi dati Blue Wave in un unico blob LZW-compresso, per farci ricerche
e altro (per quello usavo una versione ad hoc della libreria PKWare).
In compenso ho ritrovato il BWRED, un killfile per Blue Wave in asm.
Leonardo che deve ravanare fra un po' di CD
Microsoft Outlook: R: Re: R: Re: R: Re: R: cosa vuoi replicare oggi?

Ciao 
ser...@tin.it
,
Giovedi` 03 Agosto 2000 alle 08:59, 
ser...@tin.it
 scrisse a All riguardo < Re:
Blue Wave >:
 >>>> Di scrivere un client news che esporti dei pacchetti BlueWave.
 >>> Ehi, io ho ancora un sacco di codice C per leggere e scrivere Blue
Lo sapete comunque che sono disponibili i sorgenti di multimail (mmail*.*, GPL)
che legge e scrive pacchetti bw?
Ciao,
FC
FidoWEB -> 
http://bbs.romacivica.net/fido

In compenso ho ritrovato il BWRED, un killfile per Blue Wave in asm.
In asm? Robe da matti. Il killfile  piu` veloce del West? Piu` veloce di
Thorin? (-:
-- 
  _      ___ ____
 | | /| / (_)_  /
 | |/ |/ / / / /_	ANTI-SPAM WARNING:
 |__/|__/_/ /___/	the e-mail address is fake.
 
Maiale e` spaziale! (Wiz)

Thorin? (-:
Probabilmente. E un buon esempio di programmazione macellaia.
;
; Blue Wave REmove Data
;
;
FTISIZE         EQU     186d
BUFITEMS        EQU     300d
NAMESIZE        EQU     4096d
.8086
.model tiny
.code
	org	100h
start:  cld
        mov     dx,offset copyrt        ; Print copyright message
	mov	ah,09h
	int	21h
	mov	di,0080h		; Get parameter length
	mov	al,[di]
	or	al,al
	jnz	ok_nh			; If zero give help
syn:    mov     dx,offset syntax
	jmp	abort
ok_nh:  inc     di
        inc     di
        mov     al,20h
        mov     cx,080h
	repnz	scasb
        jcxz    syn
        mov     dx,di
        dec     di
        mov     [ext],di
        mov     al,0Dh
        repnz   scasb
        xor     al,al
        dec     di
        stosb
	mov	ax,3D02h		; Else try to open file
        int     21h                     ;
	jc	exit1			; Signal errors, if any
        mov     bx,ax                   ;
        mov     cx,NAMESIZE             ;
        mov     dx,offset namebuffer    ;
        mov     ah,3Fh                  ; Read at most BUFSIZE bytes
        int     21h                     ;
exit1:  jc      exit2                   ;
        mov     [namesize],ax           ;
        mov     cx,ax                   ;
        mov     ah,3Eh                  ;
        int     21h                     ;
;
; Now convert names
;
        call    xlower
;
; Now begin FTI processing.
;
        mov     di,[ext]
        mov     al,'.'
        stosb
        push    di
        mov     ax,'TX'
        stosw
        mov     ax,'I'
        stosw
        pop     di
        mov     dx,82h
        mov     ax,3D02h
        int     21h
exit2:  jc      exit3
        mov     [xtih],ax
        mov     al,'F'
        stosb
        mov     ax,3D02h
        int     21h
exit3:  jc      exit4
        mov     [ftih],ax
chunk:  db      0B9h            ;;; mov     cx,[hipos]
hipos   dw      0
        db      0BAh            ;;; mov     dx,[lopos]
lopos   dw      0
        mov     bx,[xtih]
        mov     ax,4200h
        int     21h
        mov     ah,3Fh           ;; READ XTI
        mov     cx,2d*BUFITEMS
        mov     dx,offset xtibuffer
        int     21h
        shr     ax,1
        jz      done
        mov     [samples],ax
        mov     ah,3Fh
        mov     bx,[ftih]
        mov     cx,FTISIZE*BUFITEMS
        mov     dx,offset ftibuffer
        int     21h
exit4:  jc      exit5
        call    xlower
        db      0B9h                         ;;; mov     cx,[samples]
samples dw      0
        mov     si,offset ftibuffer
        mov     bx,offset xtibuffer
again:  mov     dx,si
        add     si,FTISIZE
        call    compare
        jc      kill
        add     dx,36d
        call    compare
        jnc     unkill
kill:   or      word ptr [bx],0800h
unkill: inc     bx
        inc     bx
        loop    again
        mov     cx,[hipos]
        mov     dx,[lopos]
        mov     bx,[xtih]
        mov     ax,4200h
        int     21h
        mov     ah,40h
        mov     cx,[samples]
        shl     cx,1
        add     [lopos],cx
        adc     [hipos],0
        mov     dx,offset xtibuffer
        int     21h
exit5:  jc      exit
        jmp     chunk
done:   mov     dx,offset okay
        jmp     abort
exit:   mov     dx,offset fileio
abort:	mov	ah,09h
        int     21h
        cld
        mov     di,offset nameset
        mov     cx,200h
        rep     stosw
	mov	ax,4C00h
	int	21h
; DX points to ASCIIZ string
; Preserve BX,CX,DX,SI
compare:
        push    bx
        push    cx
        push    dx
        push    si
        mov     si,offset nameset       ; Inizia per "0"
        mov     bx,[namesize]
        add     bx,offset namebuffer    ;
        inc     bx
        inc     bx
sync:   lodsb
        or      al,al
        jnz     sync
        lodsb                           ; Second zero
        mov     di,dx
next:   mov     al,[si]
        cmpsb
        jne     sync
        or      al,al
        stc
        jz      equals
        cmp     si,bx
        jb      next
        clc
equals: pop     si
        pop     dx
        pop     cx
        pop     bx
        ret
xlower:
        mov     si,dx
        mov     di,dx
lower:  lodsb
        cmp     al,20h
        jae     ok
        xor     al,al
        jmp     ok2
ok:     or      al,20h
        inc     dx
ok2:    stosb
        loop    lower
        xor     ax,ax
        mov     cx,100h
        rep     stosw
        ret
ext             dw      0
xtih            dw      0
ftih            dw      0
namesize        dw      0
fileio          db      'I/O error$'
okay            db      'OK.$'
copyrt          db      'BlueWave Twitter v2.2',0Dh,0Ah,24h
syntax          db      'Use: BWKILL pktname twitfile',0Dh,0Ah
                db      'Ex.: BWKILL F:\WORK\XBBS
F:\TWIT.TXT',0Dh,0Ah,24h
nameset         db      0,0
;;                db    //:-)
namebuffer      equ     $
xtibuffer       equ     namebuffer + NAMESIZE
ftibuffer       equ     xtibuffer  + 2*BUFITEMS + 8
	end	start
".signature": bad command or file name

Probabilmente. E un buon esempio di programmazione macellaia.
Vabbe`. Dando per scontato che ci  capisca qualcosa. (-: L'unico asm che
io abbia mai studiato era quello del MIPS R/2000!
-- 
  _      ___ ____
 | | /| / (_)_  /
 | |/ |/ / / / /_	ANTI-SPAM WARNING:
 |__/|__/_/ /___/	the e-mail address is fake.
 
My opinion is just a point of view, and your position is the other side.
(Fates Warning)

compare nelle intestazioni, ma 
radi...@tin.it
Tepòssino.
Leonardo reinviante
