Создание подпрограммы преобразования 128-разрядного СЧ в УЧ

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Содержание

Введение

Анализ

Блок-схема основной программы.

Линейная схема основной программы.

Верификация

1. Без ветвлений

2. С ветвлением

3. Цикла

Сети Петри.

Операционная семантика

Заключение.

Приложение. Листинг программы

Введение

Подпрограмма преобразования 128-разрядного СЧ в УЧ.

Анализ

В окончательной версии программы реализован ввод с клавиатуры числа, длиной не более 128 символов, проверка его на корректность ввода, преобразование из символьного представления в УЧ, размещение полученного числа в выделенной оперативной памяти.

Tabl db '0123456789' - таблица для проверки корректности ввода данных

flag db 0 - искусственный флаг

dlina_1 db 0 - хранит длину числа

buf dw 0 - буфер

BLOCK_SEG1 dw 0 - хранит адрес блока выделенной ОП для числа

Блок-схема основной программы

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Линейная схема основной программы

0. СТАРТ (x)

// x - число, введенное с клавиатуры

1. ЕСЛИ P(x), то на 2, иначе на 4

2. x1=f1(x)

3. x2=f2(x1)

4. СТОП (x2)

Расшифровка символов, использующихся в данной схеме:

Переменные:

x, x1, x2.

Функциональные символы:

- операция перевода числа во внутреннее представление

- операция перевода в УЧ

Предикатные символы:

P - `Если числа введены корректно'

Cпециальные символы:

старт, стоп, если.

Аксиоматическая семантика

Множества

Z- множество целых чисел

R- множество регистров

L-множество меток

Операции

+ сложить

- вычесть

неравно

= равно

:= присвоить

выполнить действия за стрелкой, если выполняются условия до стрелки

@ обратиться по адресу

( ) извлечь содержимое

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

& логическое и

…

e4:

xor ax, ax ;(ax)=0

xor bx, bx ;(bx)=0

xor si, si ;(si)=0

mov al, a+1 ; (al)=(@(a1)+1)

mov si, ax ;(si)=(ax)

xor di, di ;(di)=0

mov di, si ;(di)=(si)

xor ax, ax ;(ax)=0

dec di ; (di)t = (di)(t-1)-1

…

ClrScr proc

push bp ; ((sp):=(sp)-2)&((@(ss)+(@(sp)))=(bp))

mov bp, sp ;(bp)=(sp)

push ax ; ((sp):=(sp)-2)&((@(ss)+(@(sp)))=(ax))

mov ah, 0 ;(ah)=0

mov al, 2 ;(al)=2

int 10h ; (sp)t=(sp)(t-1)-2, (sp)=(Flags), (sp)t=(sp)(t-1)-2, (sp)=(ip), (ip)=(132)

pop ax ;((ax)=(@(ss)+(@(sp))))&((sp):=(sp)+2)

pop bp ;((bp)=(@(ss)+(@(sp))))&((sp):=(sp)+2)

ret ; Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

RET

ClrScr endp

Верификация

1. Без ветвлений

mov ax, di S1

mov a1[si],al S2

inc si S3

Иcпользуем метод обратной волны:

TRUE

2. С ветвлением

cmp si,0

je Konec

sbb al,bl

…

Konec:

xor bx,bx

mov bl,dlina_1

Для доказательства того, что

(si>0)(si=0)

{ if si=0 then al=al-bl else bx=0}

(bx=0)

Необходимо доказать три условия истинности:

1) без побочных эффектов (si>0)

2) ((si>0)(si=0)) & (si>0) {al=al-bl} (al=al-blbx=0)

((si>0)(si=0)) & (si>0) ( al-bl = al-bl bx=0)

True True

3) ((si>0)(si=0)) & (si=0) {bx=0} (al=al-blbx=0)

((si>0)(si=0)) & (si=0) (al=al-bl0=0)

True True

3. Цикла

dlina_1=число введенных знаков

dlina_2=число введенных знаков

;(dlina_1>dlina_2)

…

di = dlina_2

mov bl,dlina_1

metka:

inc di

mov es,BLOCK_SEG1

…

cmp di,bx

jne metka

mov di,2

mov cl,adg

LViv:

mov al,buf3[di]

inc di

…

loop LViv

P = di > 0 bx > 0

B = (di!=bx)

Q = (di=bx)

S = (es=BLOCK_SEG1 di=di+1)

D = (bx-di)

Inv = (bx > 0)

di = bx

Покажем, что цикл всегда завершается, и продемонстрируем истинность следующих утверждений:

1) P->Inv

di > 0 bx > 0 bx > 0 True

2) Inv {B} Inv

bx>0 {di!=bx} bx>0 True

3) Inv B {S} Inv

bx>0 di!=bx {es = BLOCK_SEG1 di=di+1} bx>0

bx>0 {es=BLOCK_SEG1} bx>0

bx>0 -> bx>0 True

4) Inv !B = Q

bx>0 di=bx -> di=bx True

5) D= B Inv {S} D <

(bx-di=) (di!=bx) (bx>0) {es = BLOCK_SEG1 di=di+1}(bx-di<)

(bx-di=) (di!=bx) (bx>0) -> bx - (di+1)< True

6) D = {B} D<=

bx - di = {di!=bx} bx-di<=

bx - di = -> bx - di <= True

7) D=0 Inv -> !B

bx-di=0 bx>0 -> !!(di=bx)

bx-di=0 bx>0 -> di=bx True

Сети Петри

Для построения сети Петри была выбрана основная программа

Операционная семантика

Для написания операционной семантики была выбрана команда dec.

Будем использовать одну ленту L1 и алфавит {0,1,#}.

L1:

1. q0101R1q01

2. q0111R1q01

3. q01#1L1q11

4. q1101q2111

5. q2111L1q11

6. q1111q3101

7. q11Top1R1q31

q3 - состояние, при котором выполняется остановка работы данной машины Тьюринга

Заключение

В результате проделанной работы были изучены основы программирования на языке Ассемблер, операционная семантика, проведена верификация линейного участка подпрограммы, участков с ветвлением и циклом, изучены сети Петри, составлена схема подпрограммы. Также была изучена работа с упакованными десятичными числами.

Приложение. Листинг программы

программа вычисление линейный графический

Вычитание 2х УДЦ с произвольным количеством разрядов

Prog1 segment

assume cs:Prog1, ds:Prog1

s1 db 'Vvedite 1-e chislo$'

s2 db 'Vvedite 2-e chislo$'

s3 db 'Rezyltat:$'

NULL db '0$'

er db 'oshibka vvoda!$'

a db 102 ;для 1го числа

db 0

a1 db 100 dup(0)

b db 102 ;для 2го числа

db 0

b1 db 100 dup(0)

Tabl db '0123456789'

simvol db ' $'

znak db ' $'

flag db 0

dlina_1 db 0 ;хранит длину 1го числа

dlina_2 db 0 ;хранит длину 2го числа

zz dw 0

k10 dw 10

buf dw 0

BLOCK_SEG1 dw 0 ;хранит адрес блока выделенной ОП для первого числа

BLOCK_SEG2 dw 0 ;хранит адрес блока выделенной ОП для второго числа

REZ dw 0 ;хранит адрес блока выделенной ОП для результата

Proc1 proc

push cs

pop ds

call ClrScr

;############################################################

;Ввод чисел и перевод их в нужную форму

;############################################################

;Курсор влево вверх

xor dx,dx

push dx

call CXY

pop zz

; Вывод сообщения s1 на экран

lea dx, s1

mov ah, 09H

int 21H

;Курсор на следующую строку

mov dh,1

xor dl,dl

push dx

call CXY

pop zz

; Ввод первого числа

mov ah, 0AH

lea dx, a

int 21H

;Проверка на длину числа

cmp a+1, 0

jne L1

jmp eoj

L1:

cmp a+1, 101

jne L2

jmp eoj

L2:

;Курсор на следующую строку

mov dh,2

xor dl,dl

push dx

call CXY

pop zz

;Проверка правильности ввода 1го числа

mov bl,a+1

xor ch, ch

xor si, si

c1:

xor di, di

mov al, a1[si]

c2:

cmp al, Tabl[di]

je c3

inc di

cmp di, 10

je c4

jne c2

c3:

inc si

cmp si, bx

je c5

jne c1

c4:

call Error

c5:

; Вывод сообщения s2 на экран

lea dx, s2

mov ah, 09H

int 21H

;На след строку курсор

mov dh,3

xor dl,dl

push dx

call CXY

pop zz

; Ввод второго числа

mov ah, 0AH

lea dx, b

int 21H

;Проверка на длину числа

cmp b+1, 0

jne L3

jmp eoj

L3:

cmp b+1, 101

jne L4

jmp eoj

L4:

;На след строку курсор

mov dh,4

xor dl,dl

push dx

call CXY

pop zz

;Проверка правильности ввода 2го числа

xor bx, bx

mov bl, b+1

xor ch, ch

xor si, si

c6:

xor di, di

mov al, b1[si]

c7:

cmp al, Tabl[di]

je c8

inc di

cmp di, 10

je c9

jne c7

c8:

inc si

cmp si, bx

je c10

jne c6

c9:

call Error

c10:

;Проверка. Если числа равны по длине то найти наибольшее.

;Если числа равны то вывести 0 на экран

;Если второе число меньше первого то выставить флаг и поставить знак "-"

xor ax,ax

xor bx,bx

xor di,di

mov al,a+1

mov bl,b+1

cmp ax,bx

je c11

jne c12

c11:

mov al,a+1

cmp di,ax

je w3

mov al,a1[di]

mov bl,b1[di]

cmp ax,bx

je w1

jg c12

jl w2

w1:

inc di

jmp c11

w2:

mov znak,'-'

mov flag,1

jmp c12

w3:

lea dx, s3

mov ah, 09H

int 21H

lea dx, NULL

mov ah, 09H

int 21H

jmp eoj

c12:

;Приведение чисел во внутреннее представление

;1е число к виду 01 02 03 04 05

xor ax, ax

xor si, si

xor bx, bx

mov bl, a+1

e1:

xor di, di

mov al, a1[si]

e2:

cmp al, Tabl[di]

je e3

inc di

cmp di, 10

jne e2

e3:

mov ax, di

mov a1[si],al

inc si

cmp si, bx

je e4

jne e1

;перевод к виду 01 23 45

e4:

xor ax, ax

xor bx, bx

xor si, si

mov al, a+1

mov si, ax

xor di, di

mov di, si

xor ax, ax

dec di

cmp si, 2

je ob1

jne ob2

ob1: ;если число из 2х символов(на всякий случай чистим a1[2])

mov a1[2],'#'

ob2:

cmp si, 1

jne e5

je r1

r1: ;если число из 1го символа

jmp r2

e5:

dec si

dec si

mov al, a1[si] ;умножаем n число на 10

mov bl, 10h

mul bl

inc si

mov bl, a1[si] ;прибавляем к получившемуся n+1 элемент и пишем в diый

add al, bl

mov a1[si], 0

dec si

mov a1[si], 0

mov a1[di], al

dec di

cmp si, 1

je e6

jl e6

jne e5

e6:

mov al, a+2

mov a1[di], al

xor ax,ax

mov al,a+1

cmp ax,2

je r2

mov a+2, 0

cmp ax,3

je r2

mov a+3, 0

;2е число к (01 02 03 04 05):

r2:

xor ax, ax

xor si, si

xor bx, bx

mov bl, b+1

e7:

xor di, di

mov al, b1[si]

e8:

cmp al, Tabl[di]

je e9

inc di

cmp di, 16

jne e8

e9:

mov ax, di

mov b1[si],al

inc si

cmp si, bx

je e10

jne e7

;к виду 01 23 45

e10:

xor ax, ax

xor bx, bx

xor si, si

mov al, b+1

mov si, ax

xor di, di

mov di, si

xor ax, ax

dec di

cmp si, 2

je ob3

jne ob4

ob3: ;если число из 2х символов(на всякий случай чистим b1[2])

mov b1[2],0

ob4:

cmp si, 1

jne e11

je r3

r3: ;если число из 1го символа

jmp r4

e11:

dec si

dec si

mov al, b1[si] ;умножаем n число на 10

mov bl, 10h

mul bl

inc si

mov bl, b1[si] ;прибавляем к получившемуся n+1 элемент и пишем в diый

add al, bl

mov b1[si], 0

dec si

mov b1[si], 0

mov b1[di], al

dec di

cmp si, 1

je e12

jl e12

jne e11

e12:

mov al, b+2

mov b1[di], al

xor ax,ax

mov al,b+1

cmp ax,2

je r4

mov b+2, 0

cmp ax,3

je r4

mov b+3, 0

r4:

;Сохраняем длины чисел

xor ax,ax

mov al,a+1

mov dlina_1,al

mov al,b+1

mov dlina_2,al

;############################################################

;Выделение памяти и запись чисел в выделенную память

;############################################################

;Выделяем память под первое число

mov bx,zseg ;получаем # параграфа конца программы + 1

mov ax,es ;получаем # параграфа начала программы

sub bx,ax ;вычисляем размер программы в параграфах

mov ah,4AH ;номер функции

int 21H ;освобождаем память

mov ah,48H ;номер функции

mov bx,128 ;требуем 128 параграфа

int 21H ;пытаемся отвести блок

mov BLOCK_SEG1,ax ;сохраняем адрес блока

;запись первого числа

xor ax,ax

xor di,di

xor si,si

mov al,a+1

mov si,ax

xor ax,ax

dec si

mov es, BLOCK_SEG1 ;пишем в es адрес блока

cmp si,0

je Zap_sim1

jne Zap1

Zap_sim1:

mov al,a1[si]

mov es:[di],al

jmp Zap2

Zap1:

mov al,a1[si]

mov es:[di],al

inc di

dec si

cmp si,0

je Zap2

jne Zap1

Zap2:

;Выделяем память под второе число

mov bx,zseg ;получаем # параграфа конца программы + 1

add bx,128

mov ax,es ;получаем # параграфа начала программы

sub bx,ax ;вычисляем размер программы в параграфах

mov ah,4AH ;номер функции

int 21H ;освобождаем память

mov ah,48H ;номер функции

mov bx,128 ;требуем 128 параграфа

int 21H ;пытаемся отвести блок

mov BLOCK_SEG2,ax ;сохраняем адрес блока

;запись второго числа

xor ax,ax

xor di,di

xor si,si

mov al,b+1

mov si,ax

xor ax,ax

dec si

mov es, BLOCK_SEG2 ;пишем в es адрес блока

cmp si,0

je Zap_sim2

jne Zap3

Zap_sim2:

mov al,b1[si]

mov es:[di],al

jmp Zap4

Zap3:

mov al,b1[si]

mov es:[di],al

inc di

dec si

cmp si,0

je Zap4

jne Zap3

Zap4:

;выделяем память под результат

mov bx,zseg ;получаем # параграфа конца программы + 1

add bx,256

mov ax,es ;получаем # параграфа начала программы

sub bx,ax ;вычисляем размер программы в параграфах

mov ah,4AH ;номер функции

int 21H ;освобождаем память

mov ah,48H ;номер функции

mov bx,128 ;требуем 128 параграфа

int 21H ;пытаемся отвести блок

mov REZ,ax ;сохраняем адрес блока

;############################################################

;Подготовка к вычитанию и вычитание

;############################################################

;работа с числами

mov al,dlina_1

mov bl,dlina_2

cmp al,bl ;проверка на длину числа

je ss1

jl ss2

jg ss3

ss1: ;если равны по длине

mov al, flag

cmp al,0

je Nachalo

jne ss1_1

ss1_1:

mov al,dlina_1

mov bl,dlina_2

mov dlina_1,bl

mov dlina_2,al

mov es,BLOCK_SEG1

mov buf,es

mov es,BLOCK_SEG2

mov BLOCK_SEG1,es

mov es,buf

mov BLOCK_SEG2,es

jmp Nachalo

ss2:

mov znak,'-'

jmp ss1_1

ss3:

Nachalo:

;Вычитание

xor di,di

xor si,si

xor ax,ax

mov al,dlina_2

mov si,ax

call vsub ;вызов вычитания

;Вывод ответа

xor ax, ax

xor si, si

xor bx, bx

mov al,dlina_1

mov di, ax

mov es,REZ

cmp es:[di],0

je viv1

jne vivod1

viv1:

dec di

cmp es:[di],0

je viv1

lea dx, s3

mov ah, 09H

int 21H

lea dx, znak

mov ah, 09H

int 21H

vivod1:

mov al, es:[di]

shr al, 4

or al, 30h

mov simvol, al

lea dx, simvol

mov ah, 09H

int 21H

mov al, es:[di]

and al, 0FH

or al, 30h

mov simvol, al

lea dx, simvol

mov ah, 09H

int 21H

cmp di,0

je vivod2

dec di

jmp vivod1

vivod2:

;############################################################

;Освобождение выделенной памяти после вычитания

;############################################################

;---освобождаем 1й блок

mov ax, BLOCK_SEG1 ;получаем стартовый адрес блока

mov es, ax ;помещаем его в ES

mov ah, 49H ;номер требуемой функции

int 21H ;освобождаем блок памяти

;---освобождаем 2й блок

mov ax, BLOCK_SEG2 ;получаем стартовый адрес блока

mov es, ax ;помещаем его в ES

mov ah, 49H ;номер требуемой функции

int 21H ;освобождаем блок памяти

;---освобождаем блок результата

mov ax, REZ ;получаем стартовый адрес блока

mov es, ax ;помещаем его в ES

mov ah, 49H ;номер требуемой функции

int 21H ;освобождаем блок памяти

;Конец программы

eoj: mov ah, 4CH

int 21H

Proc1 endp

;Функция "Вычитание"

vsub proc

V1:

mov es,BLOCK_SEG1

mov al,es:[di] ; в al разряд первого числа

mov es,BLOCK_SEG2

mov bl,es:[di] ;в bl разряд второго числа

jc V2 ; jc - был ли займ, если да то v3

cmp si,0 ;проверка на конец числа

je Konec

sbb al,bl ; вычитание с займом

das ; коррекция

mov es,REZ

mov es:[di],al ; сохранение результата

inc di

dec si

jmp V1

V2:

sbb al,bl

das

mov es,REZ

mov es:[di],al

inc di

dec si

jmp V1

Konec:

xor bx,bx

mov bl,dlina_1

mov es,REZ

mov es:[di],al

cmp di,bx

je m

metka:

inc di

mov es,BLOCK_SEG1

mov al,es:[di]

mov es,REZ

mov es:[di],al

cmp di,bx

jne metka

m:

ret

vsub endp

;вывод ошибки и переход к концу программы(eoj)

Error proc

lea dx, er

mov ah, 09H

int 21H

jmp eoj

Error endp

;Очистка экрана

ClrScr proc

push bp

mov bp, sp

push ax

mov ah, 0

mov al, 2

int 10h

pop ax

pop bp

ret

ClrScr endp

;Установка курсора в нужное положение на экране

CXY proc

push bp

mov bp, sp

push ax

push bx

push dx

mov bh, 0

mov ah, 2

mov dx, [bp + 4]

int 10h

pop dx

pop bx

pop ax

pop bp

ret

CXY endp

Prog1 ends

ZSEG SEGMENT

ZSEG ENDS

end proc1

Размещено на Allbest.ru