Студентам с вопросами о лабораторных работах сюда

Kirow
Какое еще макросредство. Если вы собираетесь распределять память, динамически, сами, то привыкайте это делать сразу. Выделили блок и в этом блоке все и формируете, и ничего копировать ни откуда и ни куда не надо.

1) выделили блок
2) допустим блок много больше вашей структуры, но в его начале она размещается. тогда использовав этот указатель заполняете эту структуру в этом блоке. Если тяжело врубиться, то сделайте процедуры скрывающие суть, но бесполезные (как в случае с типами на ЯВУ)

Код (Text):

1. GetStructPointer:
2. mov eax, [esp+4]
3. retn 4

Передаешь ей указатель на блок, а получаешь указатель на структуру
3) Все остальные операции выделения/освобождения памяти выполняешь с этим блоком сам. Если сложно - опять бесполезные процедуры.

 

Итак, прошли сутки, и я узнал ответ на свой вопрос.Думаю товарищ edemko отвечал то что мне надо, но я не понял как это проецировать в masm32.

И да, такая функция есть! в библиотеке kernel32

Код (Text):

1. invoke RtlMoveMemory,dest,source,numBytes

в качестве ответа я пытался получить слово MoveMemory, одно бы это слово сэкономило бы 5 часов ненужных экспериментов и насилования мозга чтобы ничего не потерять при написании.

 

мож и катит....только у меня радасм memcpy не подсвечивает + я не шарю в какой библиотеке оно находится.(memmove подсвечивает но параметры непонятно какие принимает) Ну и конечно же RtlMoveMemory\RtlZeroMemory\RtlFillMemory меня полностью удовлетворили.

 

можно ли в обработчике прерывания 1ch сделать таймер по такому принципу: вводим с консоли секунды(число), заносим число в переменную а потом его увеличить в 20 раз и уменьшать это число) после того как значение этого числа будет 0 то делаем свои черные дела)?

 

Aneor_asm
И что в этом сложного. Только ввод с клавиатуры надо делать вне обработчика, т.к. этот обработчик должен быть выполнен много раз. вариант такой. Есть глобальная переменная. Если переменная равна 0, то обработчик ничего не делает. В противном случае обработчик уменьшает значение этой переменной и если после уменьшения переменная становится равна 0, то обработчик выполняет нужное действие. основная программа же должна ввести число с клавиатуры, перевести его из текстового вида в двоичный и записать это в эту переменную. Если что-либо надо выполнять периодически, то создается 2 переменные. Если первая равна 0, то значение второй переменной копируется в первую. Если после этого значение первой переменной равно 0, то обработчик ничего не делает. Если после копирования значение первой переменной больше 0, то оно уменьшается и если после уменьшения значение становится равно 0, то программа запускает подпрограмму. Таким образом подпрограмма будет выполняться каждый раз как счетчик обнулится. Значение второй переменной вводится в основной программе. Запускать же подпрограмму надо по выходу из прерывания, путем подмены точки возврата. также указатель на запускаемую подпрограмму можно указать в 3-ей переменной. на ЯВУ это будет примерно так.

Код (Text):

1. irq1C:
2. if (timing==0)
3. {
4.   timing=timeval;
5.   if (timing)
6.   {
7.     if (!--timing) set_return_address(proc);
8.   }
9. }
10. iret
11. proc:
12. . . .
13. retf
14. dword timing=0;
15. dword timeval=0;
16. . . .
17. read(timeval)
18. . . .

 

ребят помогите написать программу ввода/вывода в масм32

 

xolinks
А чего тут помогать, берешь "Низкоуровневое программирование для DZенствующих" о консольном вводе-выводе, и вот тебе готовая программа

 

xolinks

Что вы сделали сами для решения задачи?

 

Miyamoto
написал на форуме вопрос с требованием помощи

 

rozz, прости.
Пропустил пост, а увидел сегодня.
Следующий раз, мало чего, пишите на эл. почту, видимую в свойствах профиля.
Пищит и в нас тоже иногда - не hll понимаешь.
Вылетало из-за специальных ловушек(HLT инструкция), заставляющих отладчик выскакивать там, где хочу.
Тоокшо сидел и переписывал - тест версия.
Для просмотра оберите комментарии, начиная с "format pe gui 4.0", заканчивая "invoke ..."

Код (Text):

1. ; enu: normalized mantissa -> edx:ebx:eax
2. ;      edx:ebx:eax         <- if tg_div: normalized(mantissa * 0.1)
3. ;                             if tg_mul: normalized(mantissa * 10.0)
4. ;      ecx                 <- exponent delta
5. ;      flags               <- ?
6. ; rus: нормализированная мантисса -> edx:ebx:eax
7. ;      edx:ebx:eax                <- если tg_div: нормализированная(мантисса * 0.1)
8. ;                                    если tg_mul: нормализированная(мантисса * 10.0)
9. ;      ecx                        <- экспонента(дельта)
10. ;      flags                      <- ?
11. ;
12. ;
13. ;
14. ;
15. ;
16. ;
17. ;
18. ;format pe gui 4.0
19. ;include 'win32ax.inc'
20. ;
21. ;
22. ;section '' code executable import readable writable
23. ;  library kernel32,'kernel32.dll',\
24. ;          user32,'user32.dll'
25. ;
26. ;  include 'api\kernel32.inc'
27. ;  include 'api\user32.inc'
28. ;
29. ;
30. ;  a dt $3fff:$80000000'00000000;3333333333333333333.0
31. ;
32. ;  entry $
33. ;        mov     edx,dword[a+4]
34. ;        mov     ebx,dword[a+0]
35. ;        xor     eax,eax
36. ;        movzx   esi,word[a+8]
37. ;        and     esi,$7fff
38. ;
39. ;        finit
40. ;      repeat 8
41. ;        call    tg_div
42. ;        add     si,cx
43. ;        push    si edx ebx
44. ;        fld     tbyte[esp]
45. ;        add     esp,10
46. ;      end repeat
47. ;
48. ;        finit
49. ;      repeat 8
50. ;        call    tg_mul
51. ;        add     si,cx
52. ;        push    si edx ebx
53. ;        fld     tbyte[esp]
54. ;        add     esp,10
55. ;      end repeat
56. ;
57. ;        invoke  ExitProcess,0
58. proc tg_div
59.         push    edx
60.         push    ebx
61.         push    eax
62.         push    0
63.         mov     eax,esp        ;[eax] = edx:ebx:eax:0
64.  
65.         mov     ebx,$cccc'cccc
66.         push    ebx
67.         push    ebx
68.         inc     ebx
69.         push    ebx
70.         push    0              ;[esp] = $cccc'cccc:cccc'cccc:cccc'cccd:0000'0000 = кругленное 0.1
71.  
72.         push    esp
73.         push    eax
74.         call    _128mul128     ;чудаковатый алго сначала запишет младшие 128 бит за eax, потом старшие - за esp
75.  
76.                                ;[esp] = число в 256 бит(доказат.: 11b * 11b = 3 * 3 = 9 = 1001b = 4 бит :)
77.                                ;мин. = $cccc'cccc:cccc'cccc:cccc'cccd:0000'0000         *
78.                                ;     * $8000'0000:0000'0000:0000'0000:0000'0000         =
79.                                ;     = $cccc'cccc:cccc'cccc:cccc'cccd:0000'0000 shl 127 =
80.                                ;     = $6666'6666:6666'6666:6666'6666:8000'0000...
81.                                ;видно, что старший бит может быть 0, а нам нужно возвратить "подтянутое число"(1.xxx...)
82.  
83.                                ;1.127_бит_дроби * 1.127_бит_дроби = xx.127+127_бит_дроби = xx.254_бит_дроби(пример выше) ->
84.                                ;2 бита под целую часть(пример выше), все остальное - дробь
85.                                ;все то в edx:ebx:eax не поместится - и мы просто отбрасываем часть дроби
86.  
87.         pop     ecx            ;подхватить старшую часть
88.         pop     eax
89.         pop     ebx
90.         pop     edx
91.         add     esp,4*4        ;выкинуть младшие 128 бит результата
92.         test    edx,edx        ;проверяем старший бит(который может быть 0) результата
93.         setns   cl             ;0 или 1, те. число сдвигов/нормализаций/умножений влево
94.         shld    edx,ebx,cl
95.         shld    ebx,eax,cl
96.         shld    eax,ecx,cl
97.         movzx   ecx,cl
98.         neg     ecx            ;0 или -1
99.         sub     ecx,3          ;конечная экспонента(дельта) готова
100.                                ;откуда -3: помним, что процессор видит, напр., 0.1 как 01
101.                                ;           помним простое правило: 0.1 * 0.1 = 1 * 1 / 10 / 10
102.                                ;           в нашем случае: x*2^127 * 0.1*2^127 * 2^4 <- все то мы должны учти делением:
103.                                ;           x*0.1 / 2^127+127+4 = x*0.1 / 2^258+1 <- +1 на случай разовой нормализации(neg ecx)
104.                                ;           не бойтесь, в уме суньте запятую(точку) на 255 позиций влево(нормализируем в 1.ххх...) - осталось -3
105.                                ;трудно, но с практикой станет проще
106.  
107.         ret     0              ;до встречи в <tg_mul>
108. endp
109. ;
110. proc tg_mul
111.         push    edx
112.         push    ebx
113.         push    eax
114.         push    0
115.         mov     eax,esp        ;это вы знаете
116.  
117.         push    $a000'0000
118.         push    0
119.         push    0
120.         push    0              ;это нормализированная десятка, экспонента(дельта) = +3, и правду $a = 1.010b * 2^3
121.  
122.         push    esp
123.         push    eax
124.         call    _128mul128     ;это мы тоже знаем с <tg_div>
125.  
126.         pop     ecx
127.         pop     eax
128.         pop     ebx
129.         pop     edx
130.         add     esp,4*4
131.         test    edx,edx
132.         setns   cl
133.         shld    edx,ebx,cl
134.         shld    ebx,eax,cl
135.         shld    eax,ecx,cl
136.         movzx   ecx,cl
137.         neg     ecx
138.         add     ecx,4          ;конечная экспонента(дельта) готова
139.                                ;почему тут 4 пожалуйста !попробуйте сами...
140.                                ;смотрите компенсацию: 1.xxx*2^-127 * 1.010*2^-127+3 =
141.                                ;                    = 1.xxx*1.010 * 2^-127-127+3    =
142.                                ;                    = 1.xxx*1.010 * 2^-251
143.                                ;                      судим сами... 256 бит в результате, из них 251+ecx - дробь
144.                                ;                      так сколько припадает на целую часть :?
145.                                ;                      256-(251+ecx)=5-ecx, те. кому(точку) по-любэ двинем 4 позиции вправо
146.                                ;                      напр.: 1.1111 -> 11111.
147.                                ;голова болит
148.  
149.         ret     0              ;пока
150. endp
151.  
152.  
153.  
154.  
155. ;/*
156. ;  [m2:m1] = [m2]*[m1].
157. ;  flags   <-?
158. ;  enu: low 128 bits stored at <m1> then high 128 bits stored at <m2>
159. ;       there will be fun when buffers overlap :)
160. ;       practice with <tg_div> & <tg_mul>
161. ;  rus: на выходе младшие 128 бит запишутся в <m1>, потом старшие - в <m2>
162. ;       см. также <tg_div> & <tg_mul>
163. ;*/
164. proc _128mul128; m1,m2
165.         push    ebp
166.         mov     ebp,esp
167.         push    edi
168.         mov     edi,[ebp+2*4]           ;m1
169.         push    esi
170.         mov     esi,[ebp+3*4]           ;m2
171.         push    edx ecx ebx eax         ;we'll use stepping _64mul64
172.                                         ;[m1]*[m2] =  [m1.1]*[m2.1]          + ;00I
173.                                         ;          + ([m1.1]*[m2.2]) shl 064 + ;0II
174.                                         ;          + ([m1.2]*[m2.1]) shl 064 + ;III
175.                                         ;          + ([m1.2]*[m2.2]) shl 128   ;0IV
176.         mov     edx,[esi+4]
177.         mov     ecx,[esi]
178.         mov     ebx,[edi+4]
179.         mov     eax,[edi]
180.         call    _64mul64
181.         push    0 0 0 0 edx ecx ebx eax ;00I
182.         mov     edx,[esi+12]
183.         mov     ecx,[esi+8]
184.         mov     ebx,[edi+4]
185.         mov     eax,[edi]
186.         call    _64mul64
187.         add     [ebp-12*4],eax
188.         adc     [ebp-11*4],ebx
189.         adc     [ebp-10*4],ecx
190.         adc     [ebp-9*4],edx
191.         adc     dword[ebp-8*4],0        ;0II
192.         mov     edx,[esi+4]
193.         mov     ecx,[esi]
194.         mov     ebx,[edi+12]
195.         mov     eax,[edi+8]
196.         call    _64mul64
197.         add     [ebp-12*4],eax
198.         adc     [ebp-11*4],ebx
199.         adc     [ebp-10*4],ecx
200.         adc     [ebp-9*4],edx
201.         adc     dword[ebp-8*4],0        ;III
202.         mov     edx,[esi+12]
203.         mov     ecx,[esi+8]
204.         mov     ebx,[edi+12]
205.         mov     eax,[edi+8]
206.         call    _64mul64
207.         add     [ebp-10*4],eax
208.         adc     [ebp-9*4],ebx
209.         adc     [ebp-8*4],ecx
210.         adc     [ebp-7*4],edx           ;0IV
211.         pop     dword[edi] dword[edi+4] dword[edi+8] dword[edi+12] dword[esi] dword[esi+4] dword[esi+8] dword[esi+12]
212.  
213.         pop     eax ebx ecx edx
214.         pop     esi edi
215.         leave
216.         ret     8                       ;2010_08_20
217.  
218. endp
219.  
220.  
221.  
222.  
223. ; edx:ecx:ebx:eax <- edx:ecx * ebx:eax = (edx*ebx:eax) shl 32 + ecx*ebx:eax
224. ; flags           <- result.edx + 0
225. ;
226. ; $ffffffff'ffffffff * $ffffffff'ffffffff = $ffffffff'ffffffff * $1'00000000'00000000 - $ffffffff'ffffffff = $ffffffff'ffffffff'00000000'00000000 - $ffffffff'ffffffff = $ffffffff'fffffffe'00000000'00000001 = 128bit
227. proc _64mul64
228.         push    ecx ebx eax
229.         mov     ecx,edx
230.         call    _64mul32
231.         xchg    ecx,[esp+8]
232.         xchg    ebx,[esp+4]
233.         xchg    eax,[esp]
234.         call    _64mul32
235.         pop     edx
236.         add     ebx,edx
237.         pop     edx
238.         adc     ecx,edx
239.         pop     edx
240.         adc     edx,0
241.         ret     0
242. endp
243.  
244.  
245.  
246.  
247. ; ecx:ebx:eax <- ecx * ebx:eax = (ecx*ebx) shl 32 + ecx*eax
248. ; edx         <- ecx*eax
249. ; flags       <- result.ecx + 0
250. ;
251. ; $ffffffff'ffffffff * $ffffffff = $ffffffff'ffffffff * $1'00000000 - $ffffffff'ffffffff = $ffffffff'ffffffff'00000000 - $ffffffff'ffffffff = $fffffffe'ffffffff'00000001 = 96bit
252. proc _64mul32
253.       xchg    ebx,eax
254.       mul     ecx
255.       xchg    ebx,eax
256.       xchg    edx,ecx
257.       mul     edx
258.       add     ebx,edx
259.       adc     ecx,0
260.       ret     0
261. endp

 

edemko, Да ничего страшного.
Ага, теперь не вылетает. Спасибо!

 

Чтобы не создавать тему пишу сюда. Я сделал код на ассемблере, который якобы(он зацикливается) проверяет количество положительных,отрицательных и нулевых значений. Но когда он считает в ассемблере он зацикливается. Помогите решить проблему. Заранее благодарю

Код (Text):

1. Assembler:
2. title Lab5.asm
3. .MODEL Large,Pascal
4. ; Вариант 23
5. LOCALS @@
6. .data
7. Extrn m:Word,n:Word
8. Extrn respol:Word,resotr:Word,resnol:Word
9. .code
10. public Lab5
11. arr EQU m[BX]
12. Lab5 proc far
13. ;Start procedure
14. xor SI,SI   ; младшая часть i=0
15. xor DI,DI   ; старшая часть
16. xor BX,BX   ; регистр-индекс
17. mov cx,n
18. jcxz @@Exit
19. ;=== Решение задачи ===
20. @@Begin:
21. mov DI,m    ; array[i]
22. cmp DI,0    ; if(array[i]>0)
23. JLE @@Cont  ; Нет
24. JE  @@Cont1 ; Если равно 0
25. ;=== Положительные ===
26. inc SI      ; i++
27. mov respol, SI
28. inc bx      ; Следующий элемент массива
29. inc bx
30. LOOP @@Begin
31. ;=== Отрицательные ===
32. @@Cont:
33. cmp SI,0    ; Нашли положительные результаты?
34. JG @@Cont2  ; Да
35. jmp @@Exit  ; Нет
36. ;=== 0 ===
37. @@Cont1:
38. inc SI      ; i++
39. mov resnol, SI
40. inc bx
41. inc bx
42. LOOP @@Begin
43. ;=== Отрицательные ===
44. @@Cont2:
45. inc SI      ; i++
46. mov resotr, SI
47. inc bx
48. inc bx
49. LOOP @@Begin
50. ;=== Выход ===
51. @@Exit:
52. ret
53. Lab5 endp
54. end

Код (Text):

1. Pascal:
2. Program Lab4P
3. {$l Lab5};
4. {$f+}
5. Uses CRT;
6.  
7.  
8. Label L1;
9. var
10. m : array[1..10] of Integer;
11. i                  :Integer;
12. n                  :Integer;
13. respol,resotr,resnol :Integer;
14. ch                 :Char;
15.  
16. {Vnewnie proceduri na assemblere}
17. Procedure Lab5; external;
18.  
19. function F : Boolean;
20. {Var m  : array[1..10] of integer;
21.     i  : integer; {s4et4ik}
22.    { n  : integer; {Koli4estvo}
23. Begin
24. F:=True;
25. writeln('Vvedite massiv');
26. for i:=1 to 10 do
27.  begin
28.  readln(m[i]);
29.  end;
30. n:=0;
31. {=== + ===}
32. for i:=1 to 10 do
33.  begin
34.   if m[i]>=0 then
35.    begin
36.    inc(n);
37.    end;
38.   end;
39. Writeln('Pascal:');
40. Writeln('Kol-vo polojitelnih elementov = ',n);
41. {=== - ===}
42. n:=0;
43. for i:=1 to 10 do
44.  begin
45.   if m[i]<0 then
46.    begin
47.    inc(n);
48.    end;
49.   end;
50. writeln('Kol-vo otricatelnih elementov = ',n);
51. {=== 0 ===}
52. n:=0;
53. for i:=1 to 10 do
54.  begin
55.   if m[i]=0 then
56.    begin
57.    inc(n);
58.    end;
59.   end;
60. writeln('Kol-vo nylevih elementov = ',n);
61. End;
62.  
63.  
64. Procedure ExpS;
65. Label L1;
66. Begin
67. Writeln('====================================');
68. L1:
69. if NOT F then
70. goto L1;
71. writeln('Assembler:');
72. Lab5;
73. writeln('Polojitelnih:',respol);
74. writeln('Otricatelnih:',resotr);
75. writeln('Nylevih:',resnol);
76. End;
77. {------------------------------------------------------}
78.  
79. Procedure Main;
80. Var i:Integer;
81. Begin
82. writeln('Vi4islenie elementov massiva');
83. Repeat
84. writeln('Viberite');
85. writeln('   1 - Start');
86. Writeln('   2 - Exit');
87. {$I-}
88. Readln(i);{Korrektnost' vvoda}
89. {$I+}
90. Until(IOResult=0);
91. case i of
92. 1:ExpS;
93. 2:HALT(0)
94. else Exit;
95. end
96. End;
97. begin
98. Repeat
99. ClrScr;
100. Main;
101. Writeln('Return?(y/n)');
102. ch:=ReadKey;
103. Until(ch='n') or (ch='N');
104. end.

 

перед @@Cont нужен jmp @@Exit

[add]
и @@Cont2 кстати тоже

[add]
и я долго висел, но так и не понял, что за элементы считает si

[add]
хотя можно предположить, что сумму всех (что эквивалентно количеству)

 

SI - это счетчик, черт, ведь если один счетчик считает все значения тогда он будет показывать просто кол-во элементов в массиве и все Лан как сделать так чтобы считало кол-во отрицательных, положительных и нулевых значений?И зачем надо перед @@Const1 и @@Const jmp @@Exit? Ведь так он всегда будет прыгать на конец, а мне надо чтобы после сравнения прыгало в определенную точку

 

Godod

а не пробовали
mov respol, si
mov resotr, si
mov resnol, si
@@Begin:
...
inc respol
...
inc resotr
...
inc resnol

чтобы не циклилось
loop @@Begin
jmp @@Exit
@@Cont:
...
loop @@Begin
jmp @@Exit
@@Cont2:
ЗЫ: Я сказал ПЕРЕД, а не после

 

Ок спс попробую и напишу как получилось
Результат появился, т.е. цикл пропал, даже выдало один положительный элемент. Буду разбиратся дальше

 

вот вам еще замечания

Код (Text):

1. jle label1
2. je label2

переход на label2 ни когда не произойдет

 

Почему?