Создание подпрограммы преобразования 128-разрядного СЧ в УЧ
В результате проделанной работы были изучены основы программирования на языке Ассемблер, операционная семантика, проведена верификация линейного участка подпрограммы, участков с ветвлением и циклом, изучены сети Петри, составлена схема подпрограммы. Также была изучена работа с упакованными десятичными числами. Анализ В окончательной версии программы реализован ввод с клавиатуры числа, длиной… Читать ещё >
Создание подпрограммы преобразования 128-разрядного СЧ в УЧ (реферат, курсовая, диплом, контрольная)
Содержание Введение Анализ Блок-схема основной программы.
Линейная схема основной программы.
Верификация
1. Без ветвлений
2. С ветвлением
3. Цикла Сети Петри.
Операционная семантика Заключение.
Приложение. Листинг программы
Введение
Подпрограмма преобразования 128-разрядного СЧ в УЧ.
Анализ В окончательной версии программы реализован ввод с клавиатуры числа, длиной не более 128 символов, проверка его на корректность ввода, преобразование из символьного представления в УЧ, размещение полученного числа в выделенной оперативной памяти.
Tabl db '123 456 789' - таблица для проверки корректности ввода данных
flag db 0 — искусственный флаг
dlina1 db 0 — хранит длину числа
buf dw 0 — буфер
BLOCK_SEG1 dw 0 — хранит адрес блока выделенной ОП для числа
Блок-схема основной программы
Линейная схема основной программы
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-множество меток Операции
+ сложить
— вычесть
неравно
= равно
:= присвоить
выполнить действия за стрелкой, если выполняются условия до стрелки
@ обратиться по адресу
() извлечь содержимое
& логическое и
…
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; /
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, dlina1
Для доказательства того, что
(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. Цикла
dlina1=число введенных знаков
dlina2=число введенных знаков
;(dlina1>dlina2)
…
di = dlina2
mov bl, dlina1
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 '123 456 789'
simvol db ' $'
znak db ' $'
flag db 0
dlina1 db 0 ;хранит длину 1го числа
dlina2 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 dlina1, al
mov al, b+1
mov dlina2, 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, dlina1
mov bl, dlina2
cmp al, bl ;проверка на длину числа
je ss1
jl ss2
jg ss3
ss1: ;если равны по длине
mov al, flag
cmp al, 0
je Nachalo
jne ss11
ss11:
mov al, dlina1
mov bl, dlina2
mov dlina1, bl
mov dlina2, 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 ss11
ss3:
Nachalo:
;Вычитание
xor di, di
xor si, si
xor ax, ax
mov al, dlina2
mov si, ax
call vsub ;вызов вычитания
;Вывод ответа
xor ax, ax
xor si, si
xor bx, bx
mov al, dlina1
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, dlina1
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