Форум программистов, компьютерный форум CyberForum.ru

привязка динамической библиотеки, написанной на масм32 к проекту с++ - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Создание из двух числовых массивов третьего http://www.cyberforum.ru/cpp-beginners/thread766375.html
Есть массив 1 3 22 23 24 43 4 23 24 25 44 5 24 25 26 45 6 25 26 27 46 и массив 2 1 21 41 61 81 3 23 43 63 83 4 24 44 64 84 5 25 45 65 85
C++ Сформировать типизированный файл Сформировать типизированный файл, в котором хранится информация о сотрудниках подразделения: ФИО, место рождения, год рождения. На его основе сформировать файл сотрудников, родившихся в данном городе и распечатать его. С использованием структур и без использования потоков. Помогитеееее... Вот примерное начало... #define n 5 http://www.cyberforum.ru/cpp-beginners/thread766356.html
C++ Преобразование const char* в LPCTSTR VisualStudio2010
вот код для студии: #include <Windows.h> #include <mmsystem.h> LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow) { static LPCTSTR szAppName=L"HelloWin"; HWND hwnd; MSG msg;
как оформить это на с++? (протабулировать функцию) C++
На интервале с шагом E протабулировать функцию y=x^n! нужно сделать это используя функции и без стандартных
C++ Помогите устранить ошибку в коде. http://www.cyberforum.ru/cpp-beginners/thread766317.html
Здравствуйте не могу понять почему в программе в строке 54 выдает ошибку. У меня в классе массив указателей объявлен как Static. #ifndef DATE_H #define DATE_H class date { public: date(int = 1, int = 1, int = 1990); date(int = 1, int = 1990); date(char *,int , int);
C++ Почему вектор с типом определенным пользователем не выводиться на экран? народ короче я не могу вывести решение задачи на экран Была задача: Напишите программу, в которую сначала вводится набор пар, состоящих из имени и значения, например Joe 17 и Barbara 22. Для каждой пары занесите имя в вектор names, а число — в вектор scores (в соответствующие позиции, так что если names «в"Joe", то scores ==17). Прекратите ввод, введя строку No more (т.е. следующая... подробнее

Показать сообщение отдельно
innoochka
0 / 0 / 0
Регистрация: 18.01.2013
Сообщений: 55

привязка динамической библиотеки, написанной на масм32 к проекту с++ - C++

19.01.2013, 17:21. Просмотров 261. Ответов 0
Метки (Все метки)

программа калькулятор больших чисел, правильно работает только сложение, но нам пока собственно наплевать, ибо сложение работает и хотя бы его надо запихнуть в проект с++, что собственно ниже и пробую, но пишет при вызове какую-то ересь(((
1>d:\student\asm\bin\длл\test\test\stdafx.h(8): warning C4129: m: неизвестная escape-последовательность
1>d:\student\asm\bin\длл\test\test\stdafx.h(8): warning C4129: T: неизвестная escape-последовательность
так как это не получилось, то попробовала привязать файл к асму, норм, работает как-то, грузит длл и все выполняется
проблемы с ретурном в асме(не подскажете как? ретурн на очень большое число должен быть), который я пока заменила на
леа еах, финал(в самом конце проги)
из=за этого выдает не тот ответ...ваще засада полная с программой(((
на вход подаются 2 больших числа, символ + - * /, 0 или любая константа(просто так надо, ибо не захотел с 3мя параметрами, ругался, что есть процедура с 3мя
вобщем помогите, чем сможете, ниже коды прог и архив с моими прогами

stdafx.h
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// stdafx.h: включаемый файл для стандартных системных включаемых файлов
// или включаемых файлов для конкретного проекта, которые часто используются, но
// не часто изменяются
//
 
#pragma once
 
#pragma comment(lib,"C:\masm32\bin\TESTdll.lib")
extern "C" char _stdcall SetIntTagValue(const char* num1, const char* num2,const char* sign,const char* null);
 
#include "targetver.h"
 
#include <stdio.h>
#include <tchar.h>
 
 
 
// TODO: Установите здесь ссылки на дополнительные заголовки, требующиеся для программы
test.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// test.cpp: определяет точку входа для консольного приложения.
//
 
#include "stdafx.h"
#include "windows.h"
#include <iostream>
using namespace std;
 
 
//unsigned char (*MyFunction)(unsigned char, unsigned char); //Указатель на функцию MyAsmFunction()
 
//void main()
//{
//  HINSTANCE hModule=NULL;
//  hModule=::LoadLibraryA("C:\masm32\bin\TESTdll.dll");
//  if (hModule!=NULL)
//  {
//      ::FreeLibrary(hModule); 
//  }
//  else cout << "error load Dll" << endl;
//}
 
int _tmain(int argc, _TCHAR* argv[])
{
    int i = SetIntTagValue( "5555", "8787878", "2ah", "0");
    cout << i;
    return 0;
}
TESTdll.dll
Assembler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
.386
.model flat, stdcall
option  casemap:none     
 
include \masm32\INCLUDE\windows.inc             
include \masm32\INCLUDE\comctl32.inc
include \masm32\INCLUDE\Fpu.inc
include \masm32\INCLUDE\user32.inc
include \masm32\INCLUDE\kernel32.inc                         
includelib \masm32\LIB\comctl32.lib       
includelib \masm32\LIB\Fpu.lib
includelib \masm32\LIB\user32.lib
includelib \masm32\LIB\kernel32.lib
 
 
SetIntTagValue PROTO  :BYTE, :BYTE, :byte, :byte 
 
 
ExitProcess proto :DWORD
GetStdHandle proto :DWORD
WriteConsoleA proto :DWORD, :DWORD, :DWORD, :DWORD, :DWORD 
ReadConsoleA proto :DWORD, :DWORD, :DWORD, :DWORD, :DWORD
 
 
.data
STD_INPUT_HANDLE    equ -10 ;winbase.h
STD_OUTPUT_HANDLE   equ -11
 
 
stdout dd ?
stdin dd ?
ten db 10                           ;константа 10
numsize equ 5                       ;константа просто так
cWritten dd ?                       ;хз, зачем-то нужно для Read/Write Console'ей
one equ 1                           ;адын111!!!11
errorsub db "substraction error", 0dh, 0ah      
 
number dd 5 dup (0)                 ;ЧТОБЫ ЗАДЕРЖАТЬ КОНСОЛЬ В КОНЦЕ
final db 251 dup (30h)              ;МАССИВ, В КОТОРЫЙ БУДЕТ ЗАПИСЫВАТЬСЯ РЕЗУЛЬТАТ СЛОЖЕНИЯ(а в последствии и остальных действий. Размер выбран в 2 раза больше чем, размер 
 
;массивов, в которые будут записваться исходные числа)
;num1 db 100 dup (?)                 ;МАССИВ, В КОТ. БУДЕТ ЗАПИСЫВАТЬСЯ 1-Е ЧИСЛО
;num2 db 100 dup (?)                 ;МАССИВ, В КОТ. БУДЕТ ЗАПИСЫВАТЬСЯ 2-Е ЧИСЛО
n1 dd ?                             ;Количество разрядов 1-го числа(в принципе, переменная нам не нужна)
n2 dd ?                             ;Количество разрядов 2-го числа(тоже пока нам не нужна)
letter db ?                         ;В эту переменную будем загонять символ и посимвольно выводить результат(массив final)
full db ?                           ;Флаг переполнения разряда
ca dd ?                             ;Вычитание. Если число разрядов одинаковое
;sign db ?                           ;Знак действия
h dd ?                              ;Спомогательная переменная, на случай, если количество разрядов в num1 и num2 одинаковое. Чтобы начинать вычитание не с начала, а с того момента, 
 
;как числа различаются(если смотреть со старшего разряда)
mulsize dd ?                        ;размер результата умножения, лежащего в final
mulhelper db 100 dup(30h)           ;число, через увеличение которого будем следить за умножением
f db ?                              ;аналог full для отсчета кол-во сложений в умножении
helpsize dd ?                       ;количество разрядов числа-счетчика умножения
 
.code
    
LibMain proc instance:DWORD, reason:DWORD, reserved:DWORD
 
invoke GetStdHandle, STD_OUTPUT_HANDLE 
    mov stdout, eax
invoke GetStdHandle, STD_INPUT_HANDLE 
    mov stdin, eax
 
    mov eax, 1                        ; must return NON zero to start DLL.
    ret
 
LibMain endp
 
align 4
 
SetIntTagValue proc num1:BYTE, num2:BYTE, sign :byte, null :byte
 
;============СЧИТЫВАЕМ ЗНАК ОПЕРАЦИИ============
    
    ;invoke ReadConsoleA, stdin, ADDR sign, sizeof sign, ADDR cWritten, 0
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
;_________________________________________________________________________
;||                                                                      ||
;||                         Считаем количество разрядов                  ||
;||                             в 1-м числе                              ||
;||                 Результат заносим в n1 и в регистр eax               ||
;||______________________________________________________________________||
;
count1:
    mov dl, num1[eax]
    cmp dl, 0dh                             
    je after_count1                     
    inc eax
    jne count1  
    
after_count1:
    dec eax
    mov n1, eax
 
    mov ebx,0
 
;_________________________________________________________________________
;||                                                                      ||
;||                         Считаем количество разрядов                  ||
;||                             во 2-м числе                             ||
;||                 Результат заносим в n2 и в регистр ebx               ||
;||______________________________________________________________________||
;
count2:
    mov dl, num2[ebx]
    cmp dl, 0dh                             
    je after_count2                     
    inc ebx
    jne count2  
    
after_count2:
    dec ebx
    mov n2,ebx
    
; ________________________________________________________________________
;||                                                                      ||
;||                                                                      ||
;||                         Подсчет разрядов закончен.                   ||
;||                         Число разрядов 1-го числа - n1               ||
;||                         Число разрядов 2-го числа - n2               ||
;||______________________________________________________________________||
;   
    
 
    mov cl,0
    mov full,cl
    xor ecx,ecx
    
    mov edx, 250                    ;Размер массива 251. Не берем в счет 0-ю ячейку, зарезервированную на случаю доп.разряда от флага
    push edx                        ;Записывать будем с конца
    
    cmp sign, 2dh                   ;К нам пришел "-"
    je subtraction
    cmp sign, 2ah                   ;К нам пришел "*"
    je pre_preparation
    cmp sign, 2bh                   ;К нам пришел "+"
    je summ
    cmp sign, 2dh                   ;К нам пришел "/"
    ;je divide
    
;__________________________________________________________________________________________
;||                                                                                       ||
;||                             СЛОЖЕНИЕ                                                  ||
;||        Сначала занулим флаг переполнения разряда                                      ||
;||     Алгоритм: суммирование координат векторов.  Зная количество разрядов каждого      ||
;||     числа идем(по eax, для 1-го числа, и ebx - для 2-го) от младших разрядов          ||
;||     к старшим.                                                                        ||
;||_______________________________________________________________________________________||
 
 
 
 
summ:
    mov cl, num1[eax]
    mov dl, num2[ebx]
    sub cl,30h                      ;Символ в цифру
    sub dl,30h                      ;Символ в цифру
    add cl, dl
    add cl, full
    xor edx, edx
    mov full,dl
    
    cmp cl, ten                 ;Проверяем, происходит ли переполнение разряда
    jl not_over                 ;Если произошло - меняем флаг на 1, и cl -= 10
    sub cl, ten
    inc full
not_over:
    pop edx
    add cl,30h                  ;Цифра в символ
    mov final[edx], cl          ;Записываем результат в массив final с конца(т.к. идем от младшего разряда, а выводить удобнее от старшего)
    dec edx
    push edx
    
    cmp eax,0                   ;Если разряды в первом числе закончились - переходим только ко второму числу.
    je summ2                    ;В котором тупо прибавляем единицу от флага(если есть) и переписываем остатки числа в массив final
    
    cmp ebx,0                   ;Аналогично для 2-го числа
    je summ1
    
    dec eax
    dec ebx
    
    jmp summ
 
summ1:
    dec eax
    xor ecx,ecx
    mov cl,num1[eax]
    sub cl,30h
    add cl,full
    mov dl,0
    mov full,dl
    cmp cl, ten
    jl n_over_s1
    sub cl, ten
    inc full
n_over_s1:
    pop edx
    add cl,30h
    mov final[edx], cl
    dec edx
    push edx
    
    cmp eax,0
    je show_res
    jmp summ1
    
summ2:
    cmp eax, ebx
    je show_res
    dec ebx
    xor ecx,ecx
    mov cl,num2[ebx]
    sub cl, 30h
    add cl,full
    mov dl,0
    mov full,dl
    cmp cl, ten
    jl n_over_s2
    sub cl, ten
    inc full
n_over_s2:
    pop edx
    add cl,30h
    mov final[edx], cl
    dec edx
    push edx
    
    cmp ebx,0
    je show_res
    jmp summ2
    
    
; ________________________________________________________________________
;||                                                                      ||
;||                                                                      ||
;||                         ВЫЧИТАНИЕ                                    ||
;||                                                                      ||
;||______________________________________________________________________||
;   Алгоритм: из 2х чисел определяем наибольшее и находим модуль их разности(при желании можно вначале просто минус приделать)
;   Сначала сравниваем количество разрядов. Если длины разрядов равны - сравниваем посимвольно со старшего разряда
;   Причем если на r-том символе, например, 1-е число больше 2-го, то начинаем вычитать поразрядно из 1-го число 2-е.
;   Но вычитание, в таком случае, происходит с r-го символа, а не с начала(ололо экономия памяти)
;   
subtraction:
    mov ca,0
    cmp eax,ebx                 ;Сравниваем кол-во разрядов
    jg f_g                      ;1-е число длиннее
    jl s_g                      ;2-е число длиннее
    
    mov eax,0                   ;если число разрядов одинаковое - сравниваем посимвольно
sub_equal:  
    mov cl, num1[eax]
    mov dl, num2[eax]
    cmp cl,dl
    jg f_g
    jl s_g
    cmp eax,n1                  ;Сравнили все символы, и в 2х числах они одинаковые - результатом будет ноль
    je zero_res
    inc eax                     ;Первые символы совпадают - смотрим вторые
    jmp sub_equal
 
; ________________________________________________________________________
;||                                                                      ||
;||                         ПЕРВОЕ ЧИСЛО БОЛЬШЕ                          ||
;||______________________________________________________________________||
;
f_g:
    xor ecx,ecx                     ;Подготовка с подсчету разности
    xor edx,edx                     ;Если мы узнали, что 1 число больше 2-го, 
    mov h,eax                       ;а количество разрядов в числах одинаковое  
    mov eax,n1                      ;то надо запомнить номер разряда, на котором числа начинают различаться
    cmp eax,ebx                     ;и с него уже начинать вычитание
    jne f_g_count
    xor eax,eax
    mov eax,h
    mov ca,eax
    xor eax,eax
    mov eax,n1
f_g_count:
    mov cl, num1[eax]
    mov dl, num2[ebx]
    sub cl,30h                      
    sub dl,30h
    cmp full,1                      ;Флаг недостатка. Если равен 1, то нужно вычесть из числа в текущем разряде 1 и занулить флаг.
    jne f_sub_not_over              ;Противные случаи, когда разряд равен нулю и приходит флаг,
    cmp cl,0                        ;говорящий о том, что в предыдущем разряде тож был недостаток 
    je f_zero_cl                    ;приходится обрабатывать отедельно.
    dec cl
    dec full
f_zero_cl:
    add cl,9                        ;на нулевое значение числа в разряде пришел флаг 
                                    ;=> увеличиваем число на 9, а флаг не меняем
f_sub_not_over:
    cmp cl,dl
    jge f_not_less
    add cl,ten
    inc full
f_not_less:
    sub cl,dl
    add cl,30h
    xor edx,edx
    pop edx
    mov final[edx],cl
    dec edx
    push edx
    
    cmp ebx,ca
    je sub_final
    dec ebx
    dec eax
    jmp f_g_count
    
; ________________________________________________________________________
;||                                                                      ||
;||                         ПЕРВОЕ ЧИСЛО БОЛЬШЕ                          ||
;||______________________________________________________________________||
;   КОММЕНТАРИИ АНАЛОГИЧНЫ
s_g:
    xor ecx,ecx
    xor edx,edx
    mov h,eax
    mov eax,n1
    cmp eax,ebx
    jne s_g_count
    xor eax,eax
    mov eax,h
    mov ca,eax
    xor eax,eax
    mov eax,n1
s_g_count:
    mov dl, num1[eax]
    mov cl, num2[ebx]
    sub cl,30h                      ;Символ в цифру
    sub dl,30h
    cmp full,1
    jne s_sub_not_over
    cmp cl,0
    je s_zero_cl
    dec cl
    dec full
s_zero_cl:
    add cl,9    
s_sub_not_over:
    cmp cl,dl
    jge s_not_less
    add cl,ten
    inc full
s_not_less:
    sub cl,dl
    add cl,30h
    xor edx,edx
    pop edx
    mov final[edx],cl
    dec edx
    push edx
    
    cmp eax,ca
    je sub_final
    dec ebx
    dec eax
    jmp s_g_count
;_________________________________________________________________________
;||                                                                      ||
;||                                                                      ||
;||                         УМНОЖЕНИЕ                                    ||
;||                                                                      ||
;||______________________________________________________________________||
;Алгоритм: будем складывать 1-е число с самим собой количество раз, равно 2-му числу.
;Сначала запишем 1-е числов массив final(имеющий достаточную длину)
;Затем тупо прибавляем к final 1-е число, постепенно наращивая число mulhelper, пока mulhelper не будет равным второму числу
;Особенности: для вывода, да и вообще, нужно отслеживать количество разрядов final(в переменной mulsize) и mulhelper(в переменной helpsize)
;   
;
 
;_________________________________________________________________________
;||                                                                      ||
;||                         ПОДГОТОВКА                                   ||
;||______________________________________________________________________||
;Проверяем, не является ли 2-е число нулем или единицей. Если да, перенаправляем на соответствующий вывод
pre_preparation:
    xor ecx,ecx
    xor eax,eax
    mov eax,n2
    cmp eax,0
    jne preparation
    mov cl,num2[eax]
    cmp cl,30h
    je zero_res
    cmp cl,31h
    je one_mul_res_prep
    
preparation:
    xor ecx,ecx
    xor eax,eax
    xor ebx,ebx
    mov helpsize,0
    mov ebx,n2
    mov cl,31h
    mov mulhelper[ebx],cl
    xor cl,cl
 
    
    
;===========Копируем 1-е число в final============
    pop edx
mult:
    mov cl,num1[eax]
    mov final[edx],cl
    cmp eax,0
    je prego_mul
    dec eax
    dec edx
    jmp mult
    
    
prego_mul:
    xor ebx, ebx
    mov ebx, n1
    mov mulsize, ebx                ;запоминаем начальный размер(количество разрядов) 1-го числа. В последствии mulsize - количество разрядов результата
    
;_________________________________________________________________________
;||                                                                      ||
;||                         ГЛАВНЫЙ ЦИКЛ УМНОЖЕНИЯ                       ||
;||______________________________________________________________________||
 
go_mul:
    xor ebx,ebx
    xor eax,eax
    xor edx,edx
    xor ecx,ecx
    
;===========ПРОВЕРКА СЧЕТЧИКА УМНОЖЕНИЯ===========
;Сравниваем со старшего разряда. Если хотя один разряд, от старшего к младшему, различается, то продолжаем умножение
check:
    mov cl, num2[eax]
    mov dl, mulhelper[eax]
    cmp cl,dl
    jne continue_mul
    cmp eax,n2
    je mul_res
    inc eax
    jmp check
    
continue_mul:
    mov ebx,250
    mov eax,n1
;==========Прибавление первого числа num1 к final=============
;Вообщем-то, все так же, как и в сложении: идем от младшего разряда к старшему, и постепенно складываем, пока число не закончится
s:
    mov cl, num1[eax]
    mov dl, final[ebx]
    sub cl,30h                      
    sub dl,30h                      
    add cl, dl
    add cl, full                ;флаг переполнения разряда
    xor edx, edx
    mov full,dl
    
    cmp cl, 10                  
    jl mul_not_over             ;Если разряд не переполнен  
    sub cl, 10
    inc full
    
mul_not_over:
    add cl,30h                  
    mov final[ebx], cl          
    
    cmp eax,0                   ;см. след комментарий внизу 
    je summf                    
 
    dec eax
    dec ebx
    
    jmp s
;================ЧИСЛО num1 "КОНЧИЛОСЬ"==============
summf:
    xor ecx,ecx
    xor edx,edx
    dec ebx
    cmp full,0
    je prep_to_go_back
 
    mov cl, final[ebx]
    inc cl
    mov full,dl
    sub cl,30h
    cmp cl,10
    jl m_final_not_over
    
    sub cl,10
    mov edx,250
    sub edx,ebx
    cmp edx,mulsize
    je max_cell
    jne not_max_cell
    
max_cell:                           ;Произошло переполнение максимального разряда
    inc mulsize                     ;Увеличиваем "длину" числа
    mov cl, 30h                     ;записываем в текущую ячейку 0
    mov final[ebx],cl
    mov cl,31h                      ;а в только что "добавленную" - единицу
    dec ebx
    mov final[ebx],cl
    jmp prep_to_go_back
    
not_max_cell:
    mov cl,30h
    mov final[ebx],cl
    mov cl,1
    mov full,cl
    jmp summf
    
m_final_not_over:
    add cl,30h
    mov final[ebx], cl
    
    
    
prep_to_go_back:    
 
    xor eax,eax
    xor ebx,ebx
    xor ecx,ecx
    xor edx,edx
    mov f, dl
    
;======================КОНЕЦ УМНОЖЕНИЯ=================
    mov ebx, n2
;======================НАРАЩИВАЕМ СЧЕТЧИК УМНОЖЕНИЯ НА ЕДИНИЦУ==================
;Cитуация аналогично предыдущему сложению. Опять нужно следить за длинай числа и за переполнением старшего разряда  
mul_count:  
    mov cl, mulhelper[ebx]
    sub cl,30h
    inc cl
    
    cmp cl,10
    jl no_f_mulcounter
    
    mov edx,n2
    sub edx,ebx
    cmp edx,helpsize
    je new_help_cell
    jne mul_count_countinue
    
new_help_cell:                          ;Переполнен старший разряд. Действия по аналогии с final
    mov cl,30h
    mov mulhelper[ebx],cl
    mov cl,31h
    dec ebx
    mov mulhelper[ebx],cl
    inc helpsize
    jmp go_mul
 
mul_count_countinue:    
    sub cl,10
    add cl,30h
    inc f
    mov mulhelper[ebx],cl
    dec ebx
    jmp mulcounter_flag
 
mulcounter_flag:
    mov cl,mulhelper[ebx]
    inc cl
    dec f
    sub cl,30h
    cmp cl,10
    jl go_mul
    sub cl,10
    inc f
    add cl,30h
    mov mulhelper[ebx],cl
    dec ebx
    jmp mulcounter_flag
    
no_f_mulcounter:
    add cl,30h
    mov mulhelper[ebx],cl   
    jmp go_mul
    
 
 
 
;_________________________________________________________________________
;||                                                                      ||
;||                                                                      ||
;||                         ВЫВОД РЕЗУЛЬТАТА                             ||
;||                                                                      ||
;||______________________________________________________________________||
;
one_mul_res_prep:
    mov eax,0
one_mul_res:
    cmp eax,n1
    je exit
    xor cl,cl
    mov cl, num1[eax]
    mov letter,cl
    ;invoke  WriteConsoleA, stdout, ADDR letter,sizeof letter, ADDR cWritten, 0
    inc eax
    jmp one_mul_res
 
mul_res:
    mov eax,250
    sub eax,mulsize
    dec eax
    jmp layout_final
;=========НУЛЕВОЙ РЕЗУЛЬТАТ===========
zero_res:
    xor eax,eax
    mov eax,30h
    mov letter,al
    ;invoke  WriteConsoleA, stdout, ADDR letter,sizeof letter, ADDR cWritten, 0
    jmp exit
 
;====ПРЕДВАРИТЕЛЬНАЯ ОБРАБОТКА ДЛЯ ВЫЧИТАНИЯ====
 
sub_final:
    xor eax,eax
    pop eax
    inc eax
    jmp layout_final
 
;====ПРЕДВАРИТЕЛЬНАЯ ОБРАБОТКА ДЛЯ СЛОЖЕНИЯ====
    
show_res:
    pop eax
    cmp full, 1                             ;Дописываем последний флаговый разряд, если есть
    jne layout_final
    mov cl, 31h
    mov final[eax],cl
 
;====РЕЗУЛЬТАТ===
    
layout_final:
    cmp eax,251
    je exit
    mov dl,final[eax]
    mov letter,dl
    push eax
    ;invoke  WriteConsoleA, stdout, ADDR letter,sizeof letter, ADDR cWritten, 0
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
    pop eax
    inc eax
    jmp layout_final
 
    
exit:   
 
lea eax, final
;return SetIntTagValue.final
 
ret
SetIntTagValue endp
 
End LibMain
test.asm
Assembler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
.386
 
.model flat, stdcall 
option casemap :none 
 
      include \masm32\include\windows.inc
      include \masm32\include\user32.inc
      include \masm32\include\kernel32.inc
      include \masm32\include\shell32.inc
 
      includelib \masm32\lib\user32.lib
      includelib \masm32\lib\kernel32.lib
      includelib \masm32\lib\shell32.lib
 
      includelib TESTdll.lib
 
    SetIntTagValue PROTO  :BYTE, :BYTE, :byte, :byte 
 
.data
mestitle db "Bomz",0
form db "EAX: %u", 0
 
 
.data?
buffer db 512 dup(?)
 
.code
start:
 
invoke SetIntTagValue, 4, 8, 2ah, 3
invoke wsprintf,ADDR buffer,ADDR form,eax
invoke MessageBox,0,ADDR buffer,ADDR mestitle,MB_ICONASTERISK
invoke ExitProcess,0
end start
то, что надо переработать в длл

Assembler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
;блаблаоабала
.386
.model flat, stdcall
option  casemap:none     
 
include ..\INCLUDE\windows.inc             
include ..\INCLUDE\comctl32.inc
include ..\INCLUDE\Fpu.inc
include ..\INCLUDE\user32.inc
include ..\INCLUDE\kernel32.inc                         
includelib ..\LIB\comctl32.lib       
includelib ..\LIB\Fpu.lib
includelib ..\LIB\user32.lib
includelib ..\LIB\kernel32.lib
 
ExitProcess proto :DWORD
GetStdHandle proto :DWORD
WriteConsoleA proto :DWORD, :DWORD, :DWORD, :DWORD, :DWORD 
ReadConsoleA proto :DWORD, :DWORD, :DWORD, :DWORD, :DWORD
 
.stack 256
.data
STD_INPUT_HANDLE    equ -10 ;winbase.h
STD_OUTPUT_HANDLE   equ -11
 
 
stdout dd ?
stdin dd ?
ten db 10                           ;константа 10
numsize equ 5                       ;константа просто так
cWritten dd ?                       ;хз, зачем-то нужно для Read/Write Console'ей
one equ 1                           ;адын111!!!11
;ost db " OCTATOK: "    
 
number dd 5 dup (0)                 ;ЧТОБЫ ЗАДЕРЖАТЬ КОНСОЛЬ В КОНЦЕ
final db 3501 dup (30h)             ;МАССИВ, В КОТОРЫЙ БУДЕТ ЗАПИСЫВАТЬСЯ РЕЗУЛЬТАТ СЛОЖЕНИЯ(а в последствии и остальных действий. Размер выбран в 2 с лишним раза больше, чем размер массивов, в которые будут записваться исходные числа)
num1 db 1500 dup (?)                ;МАССИВ, В КОТ. БУДЕТ ЗАПИСЫВАТЬСЯ 1-Е ЧИСЛО
num2 db 1500 dup (?)                ;МАССИВ, В КОТ. БУДЕТ ЗАПИСЫВАТЬСЯ 2-Е ЧИСЛО
n1 dd ?                             ;Количество разрядов 1-го числа
n2 dd ?                             ;Количество разрядов 2-го числа
letter db ?                         ;В эту переменную будем загонять символ и посимвольно выводить результат(массив final)
full db ?                           ;Флаг переполнения разряда
ca dd ?                             ;Вычитание. Если число разрядов одинаковое
sign db ?                           ;Знак действия
h dd ?                              ;Вспомогательная переменная, на случай, если количество разрядов в num1 и num2 одинаковое. Чтобы начинать вычитание не с начала, а с того момента, как числа различаются(если смотреть со старшего разряда)
mulsize dd ?                        ;размер результата умножения, лежащего в final
mulhelper db 1500 dup(30h)          ;число, через увеличение которого будем следить за умножением
f db ?                              ;аналог full для отсчета кол-ва сложений в умножении
helpsize dd ?                       ;количество разрядов числа-счетчика умножения
cnum1 dd ?                          ;для деления(значение eax, в котором num1[eax] < final[ebx])
cfinal dd ?                         ;----||---- значение ebx
clear_flag db ?
 
.code
start:
invoke GetStdHandle, STD_OUTPUT_HANDLE 
    mov stdout, eax
invoke GetStdHandle, STD_INPUT_HANDLE 
    mov stdin, eax
    
;============СЧИТЫВАЕМ 1-Е ЧИСЛО============
 
    invoke ReadConsoleA, stdin, ADDR num1, sizeof num1, ADDR cWritten, 0
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
    
;============СЧИТЫВАЕМ 2-Е ЧИСЛО============
    
    invoke ReadConsoleA, stdin, ADDR num2, sizeof num2, ADDR cWritten, 0
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
 
;============СЧИТЫВАЕМ ЗНАК ОПЕРАЦИИ============
    
    invoke ReadConsoleA, stdin, ADDR sign, sizeof sign, ADDR cWritten, 0
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
;_________________________________________________________________________
;||                                                                      ||
;||                         Считаем количество разрядов                  ||
;||                             в 1-м числе                              ||
;||                 Результат заносим в n1 и в регистр eax               ||
;||______________________________________________________________________||
;
count1:
    mov dl, num1[eax]
    cmp dl, 0dh                             
    je after_count1                     
    inc eax
    jne count1  
    
after_count1:
    dec eax
    mov n1, eax
 
    mov ebx,0
 
;_________________________________________________________________________
;||                                                                      ||
;||                         Считаем количество разрядов                  ||
;||                             во 2-м числе                             ||
;||                 Результат заносим в n2 и в регистр ebx               ||
;||______________________________________________________________________||
;
count2:
    mov dl, num2[ebx]
    cmp dl, 0dh                             
    je after_count2                     
    inc ebx
    jne count2  
    
after_count2:
    dec ebx
    mov n2,ebx
    
; ________________________________________________________________________
;||                                                                      ||
;||                                                                      ||
;||                         Подсчет разрядов закончен.                   ||
;||                         Число разрядов 1-го числа - n1               ||
;||                         Число разрядов 2-го числа - n2               ||
;||______________________________________________________________________||
;   
    
 
    mov cl,0
    mov full,cl
    xor ecx,ecx
    
    mov edx, 3500                   ;Размер массива 3501. Не берем в счет 0-ю ячейку, зарезервированную на случаю доп.разряда от флага
    push edx                        ;Записывать будем с конца
    
    cmp sign, 2dh                   ;К нам пришел "-"
    je subtraction
    cmp sign, 2ah                   ;К нам пришел "*"
    je pre_preparation
    cmp sign, 2bh                   ;К нам пришел "+"
    je summ
;   cmp sign, 2fh                   ;К нам пришел "/"
;   je div_prep
    
;__________________________________________________________________________________________
;||                                                                                       ||
;||                             СЛОЖЕНИЕ                                                  ||
;||        Сначала занулим флаг переполнения разряда                                      ||
;||     Алгоритм: суммирование координат векторов.  Зная количество разрядов каждого      ||
;||     числа идем(по eax, для 1-го числа, и ebx - для 2-го) от младших разрядов          ||
;||     к старшим.                                                                        ||
;||_______________________________________________________________________________________||
 
 
 
 
summ:
    mov cl, num1[eax]
    mov dl, num2[ebx]
    sub cl,30h                      ;Символ в цифру
    sub dl,30h                      ;Символ в цифру
    add cl, dl
    add cl, full
    xor edx, edx
    mov full,dl
    
    cmp cl, ten                 ;Проверяем, происходит ли переполнение разряда
    jl not_over                 ;Если произошло - меняем флаг на 1, и cl -= 10
    sub cl, ten
    inc full
not_over:
    pop edx
    add cl,30h                  ;Цифра в символ
    mov final[edx], cl          ;Записываем результат в массив final с конца(т.к. идем от младшего разряда, а выводить удобнее от старшего)
    dec edx
    push edx
    
    cmp eax,0                   ;Если разряды в первом числе закончились - переходим только ко второму числу.
    je summ2                    ;В котором тупо прибавляем единицу от флага(если есть) и переписываем остатки числа в массив final
    
    cmp ebx,0                   ;Аналогично для 2-го числа
    je summ1
    
    dec eax
    dec ebx
    
    jmp summ
 
summ1:
    dec eax
    xor ecx,ecx
    mov cl,num1[eax]
    sub cl,30h
    add cl,full
    mov dl,0
    mov full,dl
    cmp cl, ten
    jl n_over_s1
    sub cl, ten
    inc full
n_over_s1:
    pop edx
    add cl,30h
    mov final[edx], cl
    dec edx
    push edx
    
    cmp eax,0
    je show_res
    jmp summ1
    
summ2:
    cmp eax, ebx
    je show_res
    dec ebx
    xor ecx,ecx
    mov cl,num2[ebx]
    sub cl, 30h
    add cl,full
    mov dl,0
    mov full,dl
    cmp cl, ten
    jl n_over_s2
    sub cl, ten
    inc full
n_over_s2:
    pop edx
    add cl,30h
    mov final[edx], cl
    dec edx
    push edx
    
    cmp ebx,0
    je show_res
    jmp summ2
    
    
; ________________________________________________________________________
;||                                                                      ||
;||                                                                      ||
;||                         ВЫЧИТАНИЕ                                    ||
;||                                                                      ||
;||______________________________________________________________________||
;   Алгоритм: из 2х чисел определяем наибольшее и находим модуль их разности(при желании можно вначале просто минус приделать)
;   Сначала сравниваем количество разрядов. Если длины разрядов равны - сравниваем посимвольно со старшего разряда
;   Причем если на r-том символе, например, 1-е число больше 2-го, то начинаем вычитать поразрядно из 1-го число 2-е.
;   Но вычитание, в таком случае, происходит с r-го символа, а не с начала(ололо экономия памяти)
;   
subtraction:
    mov ca,0
    cmp eax,ebx                 ;Сравниваем кол-во разрядов
    jg f_g                      ;1-е число длиннее
    jl s_g                      ;2-е число длиннее
    
    mov eax,0                   ;если число разрядов одинаковое - сравниваем посимвольно
sub_equal:  
    mov cl, num1[eax]
    mov dl, num2[eax]
    cmp cl,dl
    jg f_g
    jl s_g
    cmp eax,n1                  ;Сравнили все символы, и в 2х числах они одинаковые - результатом будет ноль
    je zero_res
    inc eax                     ;Первые символы совпадают - смотрим вторые
    jmp sub_equal
 
; ________________________________________________________________________
;||                                                                      ||
;||                         ПЕРВОЕ ЧИСЛО БОЛЬШЕ                          ||
;||______________________________________________________________________||
;
f_g:
    xor ecx,ecx                     ;Подготовка с подсчету разности
    xor edx,edx                     ;Если мы узнали, что 1 число больше 2-го, 
    mov h,eax                       ;а количество разрядов в числах одинаковое  
    mov eax,n1                      ;то надо запомнить номер разряда, на котором числа начинают различаться
    cmp eax,ebx                     ;и с него уже начинать вычитание
    jne f_g_count
    xor eax,eax
    mov eax,h
    mov ca,eax
    xor eax,eax
    mov eax,n1
f_g_count:
    mov cl, num1[eax]
    mov dl, num2[ebx]
    sub cl,30h                      
    sub dl,30h
    cmp full,1                      ;Флаг недостатка. Если равен 1, то нужно вычесть из числа в текущем разряде 1 и занулить флаг.
    jne f_sub_not_over              ;Противные случаи, когда разряд равен нулю и приходит флаг,
    cmp cl,0                        ;говорящий о том, что в предыдущем разряде тож был недостаток 
    je f_zero_cl                    ;приходится обрабатывать отедельно.
    dec cl
    dec full
f_zero_cl:
    add cl,9                        ;на нулевое значение числа в разряде пришел флаг 
                                    ;=> увеличиваем число на 9, а флаг не меняем
f_sub_not_over:
    cmp cl,dl
    jge f_not_less
    add cl,ten
    inc full
f_not_less:
    sub cl,dl
    add cl,30h
    xor edx,edx
    pop edx
    mov final[edx],cl
    dec edx
    push edx
    
    cmp ebx,ca
    je sub_final_f                      ;Второе(младшее) число "кончилось", осталось вывести остальные разряды большего(num1) числа
    dec ebx                             ;с учетом того, что может висеть флаг недостатка
    dec eax
    jmp f_g_count
 
sub_final_f:
    pop edx
    dec eax
    cmp full,0                          ;Висит или не весит флаг
    je f_res_without_decrement
    jne f_res_decrement
    
f_res_decrement:                        ;Флаг висит
    
    mov cl, num1[eax]
    sub cl,30h
    cmp cl,0
    jne stopping_full                   ;если при уменьшении числа в разряде мы снова НЕ получили недостаток
    mov cl,9
    add cl,30h
    mov final[edx],cl
    dec edx
    push edx
    jmp sub_final_f
    
stopping_full:                          ;Записываем результат
    dec cl
    add cl,30h
    mov final[edx],cl
    cmp eax,0                           ;Если это был последний разряд, то размер числа уменьшился на 1
    je minus_size                       ;Отправляемся на "урезатель" счетчика разрядов результата
    dec edx
    push edx
    xor cl,cl
    mov full,0
    jmp sub_final_f
 
minus_size:
    inc edx
    jmp f_sub_rwd_final
    
f_res_without_decrement:                ;Флаг не висит
    mov cl, num1[eax]                   ;Просто записываем в final оставшиеся разряды num1
    mov final[edx],cl
    cmp eax,0
    je f_sub_rwd_final                  ;Вывели в final все разряды - идем на выход
    dec edx
    dec eax
    jmp f_res_without_decrement
 
f_sub_rwd_final:
    mov eax,edx
    jmp layout_final
    
    
; ________________________________________________________________________
;||                                                                      ||
;||                         ВТОРОЕ ЧИСЛО БОЛЬШЕ                          ||
;||______________________________________________________________________||
;   КОММЕНТАРИИ АНАЛОГИЧНЫ
s_g:
    xor ecx,ecx
    xor edx,edx
    mov h,eax
    mov eax,n1
    cmp eax,ebx
    jne s_g_count
    xor eax,eax
    mov eax,h
    mov ca,eax
    xor eax,eax
    mov eax,n1
s_g_count:
    mov dl, num1[eax]
    mov cl, num2[ebx]
    sub cl,30h                      ;Символ в цифру
    sub dl,30h
    cmp full,1
    jne s_sub_not_over
    cmp cl,0
    je s_zero_cl
    dec cl
    dec full
s_zero_cl:
    add cl,9    
s_sub_not_over:
    cmp cl,dl
    jge s_not_less
    add cl,ten
    inc full
s_not_less:
    sub cl,dl
    add cl,30h
    xor edx,edx
    pop edx
    mov final[edx],cl
    dec edx
    push edx
    
    cmp eax,ca
    je sub_final_s
    dec ebx
    dec eax
    jmp s_g_count
    
sub_final_s:
    pop edx
    dec ebx
    cmp full,0
    je s_res_without_decrement
    jne s_res_decrement
    
s_res_decrement:
    
    mov cl, num2[ebx]
    sub cl,30h
    cmp cl,0
    jne s_stopping_full
    mov cl,9
    add cl,30h
    mov final[edx],cl
    dec edx
    push edx
    jmp sub_final_s
    
s_stopping_full:
    dec cl
    add cl,30h
    mov final[edx],cl
    cmp ebx,0
    je s_minus_size
    dec edx
    push edx
    xor cl,cl
    mov full,0
    jmp sub_final_s
 
s_minus_size:
    inc edx
    jmp s_sub_rwd_final
    
s_res_without_decrement:
    mov cl, num1[ebx]
    mov final[edx],cl
    cmp ebx,0
    je s_sub_rwd_final
    dec edx
    dec ebx
    jmp s_res_without_decrement
 
s_sub_rwd_final:
    mov eax,edx
    jmp layout_final
;_________________________________________________________________________
;||                                                                      ||
;||                                                                      ||
;||                         УМНОЖЕНИЕ                                    ||
;||                                                                      ||
;||______________________________________________________________________||
;Алгоритм: будем складывать 1-е число с самим собой количество раз, равно 2-му числу.
;Сначала запишем 1-е число в массив final(имеющий достаточную длину)
;Затем тупо прибавляем к final 1-е число, постепенно наращивая число mulhelper, пока mulhelper не будет равным второму числу
;Особенности: для вывода, да и вообще, нужно отслеживать количество разрядов final(в переменной mulsize) и mulhelper(в переменной helpsize)
;   
;
 
;_________________________________________________________________________
;||                                                                      ||
;||                         ПОДГОТОВКА                                   ||
;||______________________________________________________________________||
;Проверяем, не является ли 2-е число нулем или единицей. Если да, перенаправляем на соответствующий вывод
pre_preparation:
    xor ecx,ecx
    xor eax,eax
    mov eax,n2
    cmp eax,0
    jne preparation
    mov cl,num2[eax]
    cmp cl,30h
    je zero_res
    cmp cl,31h
    je one_mul_res_prep
    
preparation:
    xor ecx,ecx
    xor eax,eax
    xor ebx,ebx
    mov helpsize,0
    mov ebx,n2
    mov cl,31h
    mov mulhelper[ebx],cl
    xor cl,cl
 
    
    
;===========Копируем 1-е число в final============
    mov edx,3500
    mov eax,n1
mult:
    mov cl,num1[eax]
    mov final[edx],cl
    cmp eax,0
    je prego_mul
    dec eax
    dec edx
    jmp mult
    
    
prego_mul:
    xor ebx, ebx
    mov ebx, n1
    mov mulsize, ebx                ;запоминаем начальный размер(количество разрядов) 1-го числа. В последствии mulsize - количество разрядов результата
    
;_________________________________________________________________________
;||                                                                      ||
;||                         ГЛАВНЫЙ ЦИКЛ УМНОЖЕНИЯ                       ||
;||______________________________________________________________________||
 
go_mul:
    xor ebx,ebx
    xor eax,eax
    xor edx,edx
    xor ecx,ecx
    
;===========ПРОВЕРКА СЧЕТЧИКА УМНОЖЕНИЯ===========
;Сравниваем со старшего разряда. Если хотя один разряд, от старшего к младшему, различается, то продолжаем умножение
check:
    mov cl, num2[eax]
    mov dl, mulhelper[eax]
    cmp cl,dl
    jne continue_mul
    cmp eax,n2
    je mul_res
    inc eax
    jmp check
    
continue_mul:
    mov ebx,3500
    mov eax,n1
;==========Прибавление первого числа num1 к final=============
;Вообщем-то, все так же, как и в сложении: идем от младшего разряда к старшему, и постепенно складываем, пока число не закончится
s:
    mov cl, num1[eax]
    mov dl, final[ebx]
    sub cl,30h                      
    sub dl,30h                      
    add cl, dl
    add cl, full            
    xor edx, edx
    mov full,dl
    
    cmp cl,10
    jl no_full
    sub cl,10
    inc full
no_full:
    add cl,30h
    mov final[ebx],cl
    
    cmp eax,0
    je middle_part
    
    dec ebx
    dec eax
    jmp s
 
;===========Прошлись по всем разрядам в num1. Осталось следить за флагом, и в случае череполнения максимального разряда увеличить mulsize
middle_part:
    cmp full,1
    jne prep_to_go_back
    xor edx,edx
    mov edx,n1
    cmp mulsize,edx
    je add_next_cell
    jne go_flag_over_final
    
add_next_cell:
    inc mulsize
    mov cl,31h
    dec ebx
    mov final[ebx],cl
    xor cl,cl
    mov full,cl
    jmp prep_to_go_back
    
go_flag_over_final:
    cmp full,0
    je prep_to_go_back
    dec ebx
    mov cl,final[ebx]
    sub cl,30h
    inc cl
    dec full
 
    cmp cl,10
    jl simple_inc
    je full_inc
    
simple_inc: 
    add cl,30h
    mov final[ebx],cl
    jmp prep_to_go_back
 
full_inc:
    xor edx,edx
    mov cl,30h
    mov final[ebx],cl
    mov edx,3500
    sub edx,ebx
    cmp edx,mulsize
    je add_next_cell
    
    inc full
    jmp go_flag_over_final
    
;======================С суммированием закончили. Готовимся к наращиванию счетчика умножения======================  
prep_to_go_back:    
 
    xor eax,eax
    xor ebx,ebx
    xor ecx,ecx
    xor edx,edx
    mov f, dl
    
;======================КОНЕЦ УМНОЖЕНИЯ=================
    mov ebx, n2
;======================НАРАЩИВАЕМ СЧЕТЧИК УМНОЖЕНИЯ НА ЕДИНИЦУ==================
;Cитуация аналогично предыдущему сложению. Опять нужно следить за длиной числа и за переполнением старшего разряда  
mul_count:  
    mov cl,mulhelper[ebx]
    sub cl,30h
    inc cl
    cmp cl,10
    jl not_full_help
    
    cmp helpsize,0
    je first_cell_increment
    jne increment
    
first_cell_increment:
    inc helpsize
    mov cl, 30h
    mov mulhelper[ebx],cl
    mov cl,31h
    dec ebx
    mov mulhelper[ebx],cl
    jmp go_mul
    
increment:  
    mov cl,30h
    mov mulhelper[ebx],cl
    inc f
    dec ebx
    jmp help_flag
 
help_flag:
    cmp f,0
    je go_mul
    mov cl,mulhelper[ebx]
    sub cl,30h
    inc cl
    dec f
    cmp cl,10
    jl help_flag_no_inc
    je help_flag_inc
    
help_flag_no_inc:
    add cl,30h
    mov mulhelper[ebx],cl
    jmp help_flag
 
help_flag_inc:
    mov edx,n2
    sub edx,ebx
    cmp edx,helpsize
    je help_new_cell
    jne help_simple_increment
    
help_new_cell:
    mov cl,30h
    mov mulhelper[ebx],cl
    mov cl,31h
    dec ebx
    mov mulhelper[ebx],cl
    inc helpsize
    jmp go_mul
    
help_simple_increment:
    mov cl, 30h
    mov mulhelper[ebx],cl
    inc f
    dec ebx
    jmp help_flag
    
not_full_help:
    add cl,30h
    mov mulhelper[ebx],cl
    jmp go_mul
 
 
 
 
 
 
;_________________________________________________________________________
;||                                                                      ||
;||                                                                      ||
;||                             ДЕЛЕНИЕ                                  ||
;||                                                                      ||
;||______________________________________________________________________||
;
prep_div_prep:
    mov clear_flag,0
    
div_prep:
    xor ecx,ecx
    xor ebx,ebx
    mov helpsize,0
    mov ecx,123
    mov bl,31h
    mov final[ecx],bl
    xor bl,bl
    xor ecx,ecx
    
    mov edx,3500
    mov eax,n2
div_copy:
    mov cl,num2[eax]
    mov final[edx],cl
    cmp eax,0
    je prego_div
    dec eax
    dec edx
    jmp div_copy
 
prego_div:
    xor ebx, ebx
    mov ebx, n2
    mov mulsize, ebx
    mov mulsize,1
    
go_div:
    xor eax,eax
    xor ebx,ebx
    xor ecx,ecx
    xor edx,edx
 
div_check:
    mov eax,n1
    mov edx,mulsize
    cmp eax,edx
    jg continue_div
    mov eax,0
    mov ebx,3500
    sub ebx,mulsize
    
dcompare:
    mov cl,num1[eax]
    mov dl,final[ebx]
    cmp cl,dl
    jg continue_div
    jl div_sec_part
    cmp eax,n1
    je clr
    inc eax
    inc ebx
    jmp dcompare
    
continue_div:
    xor edx,edx
    mov ebx,3500
    mov eax,n2
;==========Прибавление первого числа num2 к final=============
;Вообщем-то, все так же, как и в сложении: идем от младшего разряда к старшему, и постепенно складываем, пока число не закончится
d:
    mov cl, num2[eax]
    mov dl, final[ebx]
    sub cl,30h                      
    sub dl,30h                      
    add cl, dl
    add cl, full                ;флаг переполнения разряда
    xor edx, edx
    mov full,dl
    
    cmp cl, 10                  
    jl dmul_not_over                ;Если разряд не переполнен  
    sub cl, 10
    inc full
    
dmul_not_over:
    add cl,30h                  
    mov final[ebx], cl          
    
    cmp eax,0                   ;см. след комментарий внизу 
    je dsummf                   
 
    dec eax
    dec ebx
    
    jmp d
;================ЧИСЛО num2 "КОНЧИЛОСЬ"==============
dsummf:
    xor ecx,ecx
    xor edx,edx
    dec ebx
    cmp full,0
    je dprep_to_go_back
    
    inc ebx
    mov edx,3500
    sub edx,ebx
    cmp edx,mulsize
    je dmax_cell
    
    dec ebx
    mov cl, final[ebx]
    inc cl
    mov full,dl
    sub cl,30h
    cmp cl,10
    jl d_final_not_over
    
    sub cl,10
    mov edx,3500
    sub edx,ebx
    cmp edx,mulsize
    je dmax_cell
    jne dnot_max_cell
    
dmax_cell:                          ;Произошло переполнение максимального разряда
    inc mulsize                     ;Увеличиваем "длину" числа
    dec ebx
;   mov cl, 30h                     ;записываем в текущую ячейку 0
;   mov final[ebx],cl
    mov cl,31h                      ;а в только что "добавленную" - единицу
;   dec ebx
    mov final[ebx],cl
    xor cl,cl
    mov full,cl
    jmp dprep_to_go_back
    
dnot_max_cell:
    mov cl,30h
    mov final[ebx],cl
    mov cl,1
    mov full,cl
    jmp dsummf
    
d_final_not_over:
    add cl,30h
    mov final[ebx], cl
    
dprep_to_go_back:
    xor eax,eax
    xor ebx,ebx
    xor ecx,ecx
    xor edx,edx
    mov f, dl
;======================КОНЕЦ ДЕЛЕНИЯ=================
mov ebx,123
;======================НАРАЩИВАЕМ СЧЕТЧИК УМНОЖЕНИЯ НА ЕДИНИЦУ==================
;Cитуация аналогично предыдущему сложению. Опять нужно следить за длинай числа и за переполнением старшего разряда  
div_count:  
    mov cl, final[ebx]
    sub cl,30h
    inc cl
    
    cmp cl,10
    jl no_f_divcounter
    
    mov edx,123
    sub edx,ebx
    cmp edx,helpsize
    je dnew_help_cell
    jne div_count_countinue
    
dnew_help_cell:                         ;Переполнен старший разряд. Действия по аналогии с final
    mov cl,30h
    mov final[ebx],cl
    mov cl,31h
    dec ebx
    mov final[ebx],cl
    inc helpsize
    jmp go_div
 
div_count_countinue:    
    sub cl,10
    add cl,30h
    inc f
    mov final[ebx],cl
    dec ebx
    jmp divcounter_flag
 
divcounter_flag:
    mov cl,final[ebx]
    inc cl
    dec f
    sub cl,30h
    cmp cl,10
    jl go_div
    sub cl,10
    inc f
    add cl,30h
    mov final[ebx],cl
    dec ebx
    jmp divcounter_flag
    
no_f_divcounter:
    add cl,30h
    mov final[ebx],cl   
    jmp go_div
 
    
div_sec_part:
    xor cl,cl
    mov full,cl
    mov cfinal,ebx
    mov cnum1,eax
    mov eax,n1
    mov ebx,3500
    
go_div_sec:
    mov cl, final[ebx]
    mov dl, num1[eax]
    sub cl,30h                      
    sub dl,30h
    cmp full,1                      ;Флаг недостатка. Если равен 1, то нужно вычесть из числа в текущем разряде 1 и занулить флаг.
    jne d_sub_not_over              ;Противные случаи, когда разряд равен нулю и приходит флаг,
    cmp cl,0                        ;говорящий о том, что в предыдущем разряде тож был недостаток 
    je d_zero_cl                    ;приходится обрабатывать отедельно.
    dec cl
    dec full
d_zero_cl:
    add cl,9                        ;на нулевое значение числа в разряде пришел флаг 
                                    ;=> увеличиваем число на 9, а флаг не меняем
d_sub_not_over:
    cmp cl,dl
    jge d_not_less
    add cl,ten
    inc full
d_not_less:
    sub cl,dl
    add cl,30h
    mov final[ebx],cl
    
    cmp ebx,mulsize
    je div_third_part
    dec ebx
    dec eax
    jmp go_div_sec
 
 
div_third_part:
    mov ebx,cfinal
search_begin_of_number:
    cmp final[ebx],30h
    jne next_step_third_part
    inc ebx
    jmp search_begin_of_number
    
next_step_third_part:
    mov cfinal, ebx
    mov ebx,n2
    mov eax,3500
    
ds_g_count:
    mov dl, final[eax]
    mov cl, num2[ebx]
    sub cl,30h                      ;Символ в цифру
    sub dl,30h
    cmp full,1
    jne ds_sub_not_over
    cmp cl,0
    je ds_zero_cl
    dec cl
    dec full
ds_zero_cl:
    add cl,9    
ds_sub_not_over:
    cmp cl,dl
    jge ds_not_less
    add cl,ten
    inc full
ds_not_less:
    sub cl,dl
    add cl,30h
    mov final[ebx],cl
    
    cmp eax,cfinal
    je d_sub_final
    dec ebx
    dec eax
    jmp ds_g_count
    
clr:
    mov clear_flag,1
d_sub_final:
    xor edx,edx
    mov edx,123
    sub edx,helpsize
    jmp clear_div
 
 
;_________________________________________________________________________
;||                                                                      ||
;||                                                                      ||
;||                         ВЫВОД РЕЗУЛЬТАТА                             ||
;||                                                                      ||
;||______________________________________________________________________||
;
clear_div:
    xor ecx,ecx
    mov cl,final[edx]
    mov letter,cl
    mov h,edx
    invoke  WriteConsoleA, stdout, ADDR letter,sizeof letter, ADDR cWritten, 0
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
    mov edx,h
    cmp edx,123
    mov eax,0
    je ost_prep
    inc edx
    jmp clear_div
 
ost_prep:
    cmp clear_flag,1
    je exit
    mov h,eax
    invoke  WriteConsoleA, stdout, ADDR ost,sizeof ost, ADDR cWritten, 0
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
    mov eax,h
    cmp num2[eax],30h
    jne ostat
    inc eax
    jmp ost_prep
 
ostat:
    xor cl,cl
    mov cl,num2[eax]
    mov letter,cl
    mov h,eax
    invoke  WriteConsoleA, stdout, ADDR letter,sizeof letter, ADDR cWritten, 0
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
    mov eax,h
    cmp eax,n1
    je exit
    inc eax
    jmp ostat
    
 
;===============Умножение на 1================
one_mul_res_prep:
    mov eax,0
one_mul_res:
    cmp eax,n1
    je exit
    xor cl,cl
    mov cl, num1[eax]
    mov letter,cl
    mov h,eax
    invoke  WriteConsoleA, stdout, ADDR letter,sizeof letter, ADDR cWritten, 0
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
    mov eax,h
    inc eax
    jmp one_mul_res
 
mul_res:
    mov eax,3500
    sub eax, mulsize
    jmp layout_final
;mul_real_res_wait:
;   cmp eax,3500
;   je exit
;   mov cl,final[eax]
;   cmp cl,30h
;   jne mul_real_res
;   inc eax
;   jmp mul_real_res_wait
;       
;mul_real_res:
;   mov cl,final[eax]
;   mov letter,cl
;   mov h,eax
;   invoke  WriteConsoleA, stdout, ADDR letter,sizeof letter, ADDR cWritten, 0
;   xor eax,eax
;   xor edx,edx
;   xor ebx,ebx
;   xor ecx,ecx
    
;   mov eax,h
;   cmp eax,3500
;   je exit
;   inc eax
;=========НУЛЕВОЙ РЕЗУЛЬТАТ===========
zero_res:
    xor eax,eax
    mov eax,30h
    mov letter,al
    invoke  WriteConsoleA, stdout, ADDR letter,sizeof letter, ADDR cWritten, 0
    
    jmp exit
 
;=========ПРЕДВАРИТЕЛЬНАЯ ОБРАБОТКА ДЛЯ ВЫЧИТАНИЯ=========
 
sub_final:
    xor eax,eax
    pop eax
    inc eax
    jmp layout_final
 
;=========ПРЕДВАРИТЕЛЬНАЯ ОБРАБОТКА ДЛЯ СЛОЖЕНИЯ==========
    
show_res:
    pop eax
    cmp full, 1                             ;Дописываем последний флаговый разряд, если есть
    jne layout_final
    mov cl, 31h
    mov final[eax],cl
 
;========РЕЗУЛЬТАТ========
    
layout_final:
    cmp eax,3501
    je exit
    mov dl,final[eax]
    mov letter,dl
    mov h,eax
    invoke  WriteConsoleA, stdout, ADDR letter,sizeof letter, ADDR cWritten, 0
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
    mov eax,h
    inc eax
    jmp layout_final
 
    
exit:   
    invoke ReadConsoleA, stdin, ADDR number, sizeof number, ADDR cWritten, 0 ;для задержки консоли
    xor eax, eax
    xor edx, edx
    xor ecx, ecx
    xor ebx, ebx
    invoke ReadConsoleA, stdin, ADDR num2, sizeof num2, ADDR cWritten, 0
    
    
exit2:
    invoke ExitProcess, 0 
end start
Вложения
Тип файла: zip пыщ-пыщ.zip (8.9 Кб, 1 просмотров)
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru