8 replies to this topic

[Masha]

At university i get assembly task and i really need help. Task: write a program which separates file into defined size sections(parts). Maybe someone have something like that? (P.S. sorry,I am not very good in English language :})

[mebob]

Well, maybe you could give us the code you currently have so we can help you out with it.

[Masha]

.model small
.stack
.data
    BUFSIZE EQU 4096    ;buvo 4096
    desimt dw 10
    einamasis db 0
    nuskaitem dw 0
    defin db 'input.txt', 0          ;default ivedimo failas
    defout db 12 dup(0)              ;default isvedimo failas
    msg1 db 'Irasykite ivedimo faila [input.txt]: $'
    msg2 db 10,13,'Iveskite kurimu fail dydi (max 4096b): $' 
    fin db 12 dup(?)                 ;nuskaitom input failo pavadinimas
    dydis db 0 ; 
    hin dw ?
    hout dw ?   
    buffer db BUFSIZE dup (' ')      ; buferiukas 
    bufferdu db BUFSIZE dup (' ')    ; buferiukas atvirkscias 
    panaudotasdef db 0               ;jei nuskaitem defaultini faila=1, jei savo ivedem, tai =0

.code
    mov ax, @data                    ;paruosiam duomenu segmenta
    mov ds, ax                       ;ds naudojamas nurodo segmentui atminties adresavimo metu


    mov bx, 0                        ;bx nunulinamas

;zinutes isvedimas
    MOV ah, 09h
        MOV dx, offset msg1

        INT 21h

    ;lea dx, msg1                     ;lea kaip ir offset naudojamas zinutei i ekrana isvesti

    ;mov ah, 9  
    ;int 21h

pavadinimas1: ;pavadinimas1 kartojamas kol al tampa =13

    mov ah, 1h                        ; i ekrana ivesta simboli is karto daro,ka reikia
    int 21h
    cmp al, 13
    je file1                          ;JE - Jump if Equal
    mov [bx], al                      ;al perkeliamas i bx
    inc bx                            ; bx padidinamas vienetu
    jmp pavadinimas1                  ; jump'ina i pavadinimas1 ir ciklas kartojasi

file1:      ;skaitymas is failo
    mov bx, 0   ;bx nunulinamas

;failo atidarymas
    lea dx, fin  
    mov ah, 3dh                      ;failo atidarymo komanda
    mov al, 2                        ; jei 2,tai atidarymo tikslas skaitymas ir rasymas
    int 21h

    mov ax, hin
    mov ah, 59h                      ;tikrinam ar nebuvo klaidu
    int 21h
    cmp al, 2                        ;atsakymas irasomas i al, jei al >0 - ivyko klaida
    je readdefault                   ;jump jei teisinga
    jmp nextfile 


readdefault:
    lea dx, defin
    mov ah, 3dh                      ;failo atidarymo komanda
    mov al, 2                        ;2-ir skaitymui ir rasymui
    int 21h
    mov ax, hin
    mov panaudotasdef, 1


nextfile:
    MOV ah, 09h
    MOV dx, offset msg2

    INT 21h

    ;lea dx, msg2
    ;mov ah, 9                         ;spausdinimui
    ;int 21h
    mov ax, 0                         ; nunulinamas ax
    mov bx, 0                         ; nunulinamas bx
    mov cx, 1

pavadinimas2: 
    mov ah, 1h
    int 21h
    cmp al, 13 
    je darbas                         ;jei lygu jump'ina i darbas
    sub al, 48                        ;atimtis
    mov bl, al
    mov al, dydis
    mul desimt                        ;sudaugina
    mov al, dydis
    add bl, dydis                     ;sudetis 
    jmp pavadinimas2





darbas:

    skaitymasibuferi:
    mov ah, 3fh                       ;f-ja skaitymui is failo
    mov bx, hin                       ;bx'e - failo handle
    mov ch, 0
    mov cl, dydis                     ;cx kiek baitu skaitom
    lea dx, buffer                    ;dx kur nuskaitom
    int 21h
    cmp ax, 0
    je baigiamtemp
    mov ax, nuskaitem

    mov bx, 0 
keitima:

    cmp panaudotasdef, 0              ;tikrinam ar turim savo pavadinima, ar defaultini
    je a

    mov al, defin[bx]                 ;naudojam defaultini pavadinima
    mov defout[bx], al
    inc bx                            ;padidinama vienetu
    jmp b

a:
    mov al, fin[bx]                   ;buvo ivestas ir panaudotas savo failas, todel 
    mov defout[bx], al                ;ir outpute failus padarom tokiu pat pavadinimu
    inc bx

b: 
    cmp al, 46 
    jne keitima

    mov defout[bx], 'p'
    inc bx
    cmp einamasis, 10
    jb maziaides 

daugiaudes: 
    mov ah, 0
    mov al, einamasis
    mov dx, 10
    div dl 
    add al, 48
    add ah, 48
    mov defout[bx], al 
    inc bx
    mov defout[bx], ah 
    inc bx                           ;padidinama vienetu
    mov defout[bx], 'x'
    jmp daromfaila

baigiamtemp: 
    jmp baigiam                      ;naudojam tarpini nes baigiam yra per toli nuo jumpo vietos

maziaides:
    mov defout[bx], '0'
    inc bx
    mov al, einamasis
    add al, 48
    mov defout[bx], al

;failo sukurimas
    daromfaila:
    mov ah, 3ch
    mov cx, 0                        ;nunulinimas
    lea dx, defout
    int 21h
    mov ax,hout

    mov ah, 40h                      ;f-ja rasymui i faila
    mov cx, nuskaitem                ;kiek baitu rasom
    mov bx, hout                     ;kur rasom (file) 
    lea dx, buffer                   ;ka rasom (kintamasis)
    int 21h

    mov ah, 3eh
    mov bx, hout                     ;uzdarom faila i kuri raseme
    int 21h 

    inc einamasis 

    jmp darbas 

baigiam: 
    mov ah, 3eh                      ;uzdarom faila is kurio skaitome
    mov bx, hin
    int 21h



    mov ax, 4c00h                    ;griztam i OS
    int 21h 

    end

Something like that,but it's not working how it need.. :/

Edited by Alexander, 11 December 2010 - 04:54 AM.
(code tags)

[dargueta]

Do you know specifically what the problem is?

[Masha]

it doesn't separates file into defined size sections(parts)...

[dargueta]

That's not very specific. I meant if you've traced the problem to a specific part in your program.

[Masha]

I don't know...

[Masha]

I have got another code:

.model small


.stack 100h


.data

helpas	DB "Marija Karyte, I kursas, 3 grupe; 10 Uzduotis: Parasykite programa, suskaidani faila i nurodyto dydzio gabaliukus (paskutinis gali buti mazesnis).",13,10,13,10,"$"    


pr1	DB "Nepavyko atidaryti failo skaitymui! Greiciausiai blogai ivedete.",0Dh,0Ah, "Veskite: <program name> <data file> <number> <result file>$" 

pr2		DB "Nepavyko sukurti failo rasymui! $" 

pr3		DB "Klaida skaitant faila$" 

pr4		DB "Klaida irasant i faila$" 

pr5		DB "Nepavyko uzdaryti irasomo failo!$" 

pr6		DB "Nepavyko uzdaryti nuskaityto failo!$" 


skBuf	DB 1 DUP (?)	;skaitymo buferis

raBuf	DB 20 DUP (?)	;raðymo buferis

dFail	DW ?			;vieta, skirta saugoti duomenu failo deskriptoriaus numeri ("handle")

rFail	DW ?			;vieta, skirta saugoti rezultato failo deskriptoriaus numeri


CRLF    DB 0Dh, 0Ah 

Count1 DW 0

Count2	DW 0

duom    DB 100h DUP ('$')

rez     DB 100h DUP ('$')

range	DW 0

.code


start:

    MOV ax, @data

    MOV ds, ax 

	;*********konsole**********    

    MOV bx, 81h

	LEA si, duom

	LEA di, rez

	MOV cl, -1

	INC bx

L00P:

	MOV ax, es:[bx]

	INC bx


	CMP ax, 3f2fh

	JE  found


	CMP al, 0dh

	JE  another_parameter


	CMP al, 20h					;tarpas

	JE  another_parameter


	CMP cl, 0

	JB  data

	JE  margin

	CMP cl, 1

	JE  result

data:

    MOV [si], ax

    INC si

    JMP L00P 


result:

    MOV [di], ax

    INC di  

    JMP L00P  


another_parameter:

	INC cl

	MOV al, 0 ; turi baigtis 0

	CMP cl, 1

	JB here

	JE L00P

	CMP cl, 2

	JE there

here:

	MOV [si], al

	JMP L00P

there:

	MOV [di], al

	JMP move_on

	    

found:

	LEA dx, helpas

	MOV ah, 9

	INT 21h

	JMP the_end

	;*****************************************************


margin:

	XOR dx, dx	; laikinai sunulinam DX

	MOV ch, al	; laikinai idedam nuskaityto skaitmens (is AL) reiksme i CH

	MOV ax, range	; daugybos MUL rezultatas saugomas AX registre, todel rezultato registra ikeliam i ji

	MOV range, 0

	MOV range, 0Ah	; nurodom, kad dauginsim is 10

	MUL range		; dauginam AX := AX * riba = riba * 10

	MOV range, ax	; ikeliam gauta rezultata atgal i musu skaiciaus registra

	MOV al, ch	; grazinam nuskaityta skaitmeni i AL, nes dabar ji naudosime sudeciai

	SUB al, 30h ; padarom normalu skaiciu

	XOR ah, ah	; sunulinam AH, nes reikes sudeti du 16 bitu registrus

	ADD range, ax	; prie rezultato registro pridedam musu AL

	JMP L00P ; skaitome skaiciu toliau...



;*****************************************************

;Duomenu failo atidarymas skaitymui

;*****************************************************

move_on:

	MOV	ah, 3Dh		              ;21h pertraukimo failo atidarymo funkcijos numeris

	MOV	al, 00				      ;00 - failas atidaromas skaitymui

	MOV	dx, offset duom		   	  ;vieta, kur nurodomas failo pavadinimas, pasibaigiantis nuliniu simboliu

	INT	21h				          ;failas atidaromas skaitymui

	JC	Open_for_reading_error	  ;jei atidarant faila skaitymui ivyksta klaida, nustatomas carry flag

	MOV	dFail, ax			      ;atmintyje iðsisaugom duomenu failo deskriptoriaus numeri

	JMP Result_file


Open_for_reading_error:

	LEA dx, pr1		              ;isspausdina pranesima		

	MOV ah, 9		              ;nurodo ivesti skaiciu

	INT 21h			

	JMP	the_end

;*****************************************************

;Rezultato failo sukurimas ir atidarymas rasymui

;*****************************************************

Result_file:

	MOV	ah, 3Ch			    	  ;21h pertraukimo failo sukurimo funkcijos numeris

	MOV	cx, 0				      ;kuriamo failo atributai

	MOV	dx, offset rez			  ;vieta, kur nurodomas failo pavadinimas, pasibaigiantis nuliniu simboliu

	INT	21h				          ;sukuriamas failas; jei failas jau egzistuoja, visa jo informacija iðtrinama

	JC	Open_for_writing_error	  ;jei kuriant faila skaitymui ivyksta klaida, nustatomas carry flag

	MOV	rFail, ax			      ;atmintyje issisaugom rezultato failo deskriptoriaus numeri

	JMP Read1

Open_for_writing_error:

	LEA dx, pr2		              ;isspausdina pranesima		

	MOV ah, 9		              ;nurodo ivesti skaiciu

	INT 21h			

	JMP the_end

	JMP	Close_Reading

	;*****************************************************

;Duomenu nuskaitymas is failo

;*****************************************************

Read1:

	MOV	di, offset raBuf

Read:

	MOV	ah, 3Fh			          ;21h pertraukimo duomenu nuskaitymo funkcijos numeris

	MOV	bx, dFail		          ;i bx iraðom duomenu failo deskriptoriaus numeri

	MOV	cl, 1		              ;cx - kiek baitu reikia nuskaityti is failo

	MOV	ch, 0			          ;isvalom vyresniji cx baita

	MOV	dx, offset skBuf	      ;vieta, i kuria irasoma nuskaityta informacija

	INT	21h			              ;skaitymas is failo

	JC	Reading_Error_0		      ;jei skaitant ið failo ivyksta klaida, nustatomas carry flag

	CMP	ax, 0			          ;priesingu atveju, i ax iraðoma, kiek baitu buvo nuskaityta

	JE	Into_file


;*****************************************************

;Darbas su nuskaityta informacija

;*****************************************************


	MOV	si, offset skBuf

	MOV	dl, [si] 


	CMP dl, 0Dh

	JE Zero_making

	CMP dl, 0Ah

	JE Zero_making


Further:

	MOV	[di], dl

	INC Count2      ;simboliu skaicius bufery

	INC di

	INC Count1




	CMP Count2, 20

	JE Into_file


	PUSH dx

	MOV dx, range

	CMP Count1, dx

	POP	dx


	JE Into_file


	JMP Read


Into_file:

	PUSH ax				;issaugom ax reiksme tikrinimui ar dar reikes skaityi faila

	MOV	cx, Count2		;cx - kiek baitu reikia iraðyti

	MOV Count2, 0

	MOV	ah, 40h			;21h pertraukimo duomenu iraðymo funkcijos numeris

	MOV	bx, rFail		;i bx iraðom rezultato failo deskriptoriaus numeri

	MOV	dx, offset raBuf	;vieta, ið kurios raðom i faila

	INT	21h			;raðymas i faila

	JC	Writing_Error


	PUSH dx

	MOV dx, range

	CMP Count1, dx

	POP	dx

	JE  Insert		;jei raðant i faila ivyksta klaida, nustatomas carry flag


	POP ax

	CMP ax, 0		;dar skaityti ar ne

	JE Close_Writing

	JMP	Read1		;-> reikia skaityti toliau

Reading_Error_0:

	JMP	Reading_Error

;*****************************************************

;Rezultato failo uzdarymas

;*****************************************************

Close_Writing:

	MOV	ah, 3Eh			      ;21h pertraukimo failo uþdarymo funkcijos numeris

	MOV	bx, rFail		      ;i bx iraðom rezultato failo deskriptoriaus numeri

	INT	21h			          ;failo uþdarymas

	JC	Writing_Close_Error   ;jei uþdarant faila ivyksta klaida, nustatomas carry flag


;*****************************************************

;Duomenu failo uzdarymas

;*****************************************************

Close_Reading:

	MOV	ah, 3Eh			     ;21h pertraukimo failo uþdarymo funkcijos numeris

	MOV	bx, dFail		     ;i bx iraðom duomenu failo deskriptoriaus numeri

	INT	21h			         ;failo uþdarymas

	JC	Reading_Close_Error  ;jei uþdarant faila ivyksta klaida, nustatomas carry flag


the_end:

	MOV	ah, 4Ch		        ;reikalinga kiekvienos programos pabaigoj

	MOV	al, 0		        ;reikalinga kiekvienos programos pabaigoj

	INT	21h		            ;reikalinga kiekvienos programos pabaigoj

	;*************************************************************************************************

Zero_making:  

	MOV Count1, -1;			Na beveik nulinimas

	JMP Further

;*************************************************************************************************

Reading_Error:

	LEA dx, pr3		; isspausdina pranesima, kuris aprasytas virsuje		

	MOV ah, 9		; nurodo ivesti skaiciu

	INT 21h			

	JMP the_end

	JMP	Close_Writing

Writing_Error:

	LEA dx, pr4	; isspausdina pranesima, kuris aprasytas virsuje		

	MOV ah, 9		; nurodo ivesti skaiciu

	INT 21h			

	JMP the_end

	JMP	Close_Writing

Writing_Close_Error:

	LEA dx, pr5		; isspausdina pranesima, kuris aprasytas virsuje		

	MOV ah, 9		; nurodo ivesti skaiciu

	INT 21h			

	JMP the_end

	JMP	Close_Reading

Reading_Close_Error:

	LEA dx, pr6	; isspausdina pranesima, kuris aprasytas virsuje		

	MOV ah, 9		; nurodo ivesti skaiciu

	INT 21h			

	JMP the_end



Insert:

	MOV cx, 2

	MOV	ah, 40h			

	MOV	dx, offset CRLF	

	INT	21h				

	JC	Reading_Error

	MOV Count1, 0	

	JMP Read1		




END start

but i need that the program separates file(from rez.txt) into defined size parts to different files( for example: data1.txt, data2.txt,....). I don't know,how to change part "Darbas su nuskaityta informacija" (Working with the scanned information).

Edited by dargueta, 15 December 2010 - 07:15 PM.
Added code tags

[dargueta]

I don't speak Lithuanian so the comments aren't that helpful, but this looks more complicated than it should be. Did you just jump into this and start coding, or did you plan it out carefully? Planning is essential to tackling even the simplest of problems.