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

rozz
на макросах fasmа ^)

 

Макросы использовать нельзя =/

А как мне ее заставить работать хотя бы с макросами?Для проверки, да и для общего развития

 

Должно получиться вот такое сообщение:

 

Ага, получилось. Просто я нажимала - Run(f9), а не Compile. Спасибо. А можно это реализовать не посредством макросов ?

 

Вывести числа легко, сам перекодировщик - эх.., на каком курсе такие задания дают :?
Да, если не горит.

 

На 4м
Не то, чтобы и горит, но думаю до числа 20го сделать надо =/
Вывести числа (перевод в 16ричную и 2-ю) у меня есть программа, к заданию ранее сделана, могу показать - если она чем-то поможет, но тут же немного другая ситуация.

 

ред: теряется форматирование - прикрепил файлом

 

Для ускорения <a2f> может использовать FPU, когда степень 10 ищем за формулой.
Независимая(!) вставка отмечена ";;".
Используемая <power10> дана ниже.
За англ. буквы, как всегда, простите.

Код (Text):

1.         cmp     esi,-4931
2.         jl      .edfed
3.         cmp     esi,4932
4.         jg      .edfed
5.         ;;
6.         test    byte[ebp+4*4+1],1
7.         jnz     .avoid_fpu             ; simulate fpu
8.         finit
9.         push    esi
10.         fild    dword[esp]
11.         call    power10                ; 10^esi
12.         push    ecx ebx eax
13.         fld     tbyte[esp]
14.         fmulp                          ; * intermediate integral float
15.         fxam
16.         fstsw   ax
17.         fstp    tbyte[esp]
18.         and     ah,01000101b           ; fpu.sw.{x|c3|x|x|x|c2|x|c0}
19.         cmp     ah,00000100b           ; fpu.sw.c2 =1= common number
20.         pop     eax ebx ecx esi
21.         jne     .edfed
22.         jmp     .ok
23. .avoid_fpu:
24.         ;;
25.         lea     edx,[ecx*2]            ; hide sign bit to
26.         shr     dx,1                   ; operate easily

Стандартная power10, используемая кусочком выше:

Код (Text):

1. ;power   -> st0
2. ;st0     <- 10^power
3. ;fpu.tos <- returned
4. ;ensure st5..st7 are free before calling this proc
5. proc power10
6.                        ;10^power=2^x
7.                        ;x=log(2;10^power)=log(2;10)*power
8.         fldl2t         ;log(2;10)
9.         fmulp          ;x
10.  
11.                        ;2^x=2^x.fraction*2^x.whole=2^x.fraction shl x.whole
12.         fld     st0    ;x
13.         frndint        ;x.whole
14.         fsub    st1,st0;x.fraction
15.         fxch
16.         f2xm1          ;2^x.fraction -1
17.         fld1
18.         faddp          ;2^x.fraction
19.         fscale         ;shl x.whole
20.         fstp    st1    ;10^x
21.         ret     0      ;-)
22. endp

Пример вызова:

Код (Text):

1.      stdcall a2f,src,$100        ; избегать FPU
2.      stdcall a2f,src,$000        ; вовлекать FPU
3.      stdcall a2f,src,$100 or "'" ; избегать FPU, разрешить этот символ
4.      stdcall a2f,src,$000 or ' ' ; вовлекать FPU, разрешить этот символ

В редакторе включено оптимальное сохранение.

 

edemko, Спасибо!!! Думаю такой код о-о-о-чень удивит моего педагога ОО

Вот такая вот ошибочка появляется:

 

Проверьте вторую линию исходника - там и ошибка: include 'win32ax.inc'.
Успехов.

Код (Text):

1. format pe gui 4.0
2. include 'win32ax.inc'
3.  
4.  
5.  
6.  
7.  
8.  
9.  
10.  
11. section '' resource readable writable
12.   IDD_ROZZ  = 0
13.  
14.   IDC_LBLIN = 1
15.   IDC_TXTIN = 2
16.  
17.   IDC_LBLTF = 3
18.   IDC_TXTTF = 4
19.  
20.   IDC_LBLQF = 5
21.   IDC_TXTQF = 6
22.  
23.   IDC_LBLDF = 7
24.   IDC_TXTDF = 8
25.  
26.   directory RT_DIALOG,dialogs
27.  
28.   resource dialogs,\
29.            IDD_ROZZ,0,idd_rozz
30.  
31.   dialog idd_rozz,'float',40,40,195,93,WS_CAPTION+WS_SYSMENU+WS_MINIMIZEBOX,,,'Courier New',8
32.     dialogitem 'static' ,'in:'  ,IDC_LBLIN  ,3,78,12,9    ,WS_CHILD+WS_VISIBLE
33.     dialogitem 'edit'   ,''     ,IDC_TXTIN  ,18,78,174,12 ,WS_CHILD+WS_VISIBLE+WS_TABSTOP                                                                      ,WS_EX_CLIENTEDGE
34.  
35.     dialogitem 'static' ,'tf:'  ,IDC_LBLTF  ,3,3,12,9     ,WS_CHILD+WS_VISIBLE
36.     dialogitem 'edit'   ,''     ,IDC_TXTTF  ,18,3,174,21  ,WS_CHILD+WS_VISIBLE+WS_TABSTOP+ES_WANTRETURN+ES_READONLY+ES_AUTOHSCROLL+ES_AUTOVSCROLL+ES_MULTILINE ,WS_EX_CLIENTEDGE
37.  
38.     dialogitem 'static' ,'qf:'  ,IDC_LBLQF  ,3,27,12,9    ,WS_CHILD+WS_VISIBLE
39.     dialogitem 'edit'   ,''     ,IDC_TXTQF  ,18,27,174,21 ,WS_CHILD+WS_VISIBLE+WS_TABSTOP+ES_WANTRETURN+ES_READONLY+ES_AUTOHSCROLL+ES_AUTOVSCROLL+ES_MULTILINE ,WS_EX_CLIENTEDGE
40.  
41.     dialogitem 'static' ,'df:'  ,IDC_LBLDF  ,3,51,12,9    ,WS_CHILD+WS_VISIBLE
42.     dialogitem 'edit'   ,''     ,IDC_TXTDF  ,18,51,174,21 ,WS_CHILD+WS_VISIBLE+WS_TABSTOP+ES_WANTRETURN+ES_READONLY+ES_AUTOHSCROLL+ES_AUTOVSCROLL+ES_MULTILINE ,WS_EX_CLIENTEDGE
43.   enddialog
44.  
45.  
46.  
47.  
48.  
49.  
50.  
51.  
52. section '' code executable import readable writable
53.   library kernel32,'kernel32.dll',\
54.           user32,'user32.dll'
55.  
56.   include 'api\kernel32.inc'
57.   include 'api\user32.inc'
58.  
59.   ;include '..\..\fasmme\proc.inc'
60.  
61.   buf260 rb 4+255+1
62.  
63.   entry $
64.         invoke  DialogBoxParamA,0,IDD_ROZZ,0,rozz,0
65.         ret     0
66.  
67.  
68.  
69.  
70. proc rozz uses esi edi ebx, wnd,msg,wparam,lparam
71.         mov     eax,[msg]
72.         .if     eax=WM_CLOSE
73.                 invoke  EndDialog,[wnd],eax
74.         .elseif eax=WM_COMMAND
75.                 mov     eax,[wparam]
76.                 .if     eax=EN_CHANGE shl 16 + IDC_TXTIN
77.                         invoke  SendDlgItemMessageA,[wnd],IDC_TXTIN,WM_GETTEXT,256,buf260+4
78.                         mov     dword[buf260],eax
79.                         stdcall bsa_a2f,buf260+4,$100 or "'"
80.                         jc      .oops
81.  
82.                         push    ecx ebx eax
83.                         mov     cl,10
84.                         call    .bin
85.                         mov     ebx,IDC_TXTTF
86.                         mov     cl,10
87.                         call    .hex
88.                         ;
89.                         emms
90.                         fld     tbyte[esp]
91.                         fst     qword[esp]
92.                         mov     cl,8
93.                         call    .bin
94.                         mov     ebx,IDC_TXTQF
95.                         mov     cl,8
96.                         call    .hex
97.                         ;
98.                         fstp    dword[esp]
99.                         mov     cl,4
100.                         call    .bin
101.                         mov     ebx,IDC_TXTDF
102.                         mov     cl,4
103.                         call    .hex
104.                         add     esp,3*4
105.  
106.                         call    .set_title
107.                         db      'float',0
108.                   .oops:call    .set_title
109.                         db      'F L O A T',0
110.                   .set_title:
111.                         pop     eax
112.                         invoke  SendMessageA,[wnd],WM_SETTEXT,0,eax
113.                 .endif
114.         .endif
115.  
116. .exit:  xor     eax,eax
117.         ret
118.  
119. .bin:   lea     esi,[esp+4]
120.         mov     edi,buf260+4+255-1
121.         mov     word[edi],'b'
122.         sub     edi,4
123.   .bin_loop:
124.         cld
125.         lodsb
126.         std
127.         mov     ch,al
128.         and     al,$0f
129.         movzx   eax,al
130.         mov     eax,[.bin_data+eax*4]
131.         stosd
132.         shr     ch,4
133.         movzx   eax,ch
134.         mov     eax,[.bin_data+eax*4]
135.         stosd
136.         dec     cl
137.         jnz     .bin_continue
138.         mov     eax,$0a0d shl 16 or 'h '
139.         stosd
140.         add     edi,3
141.         ret     0
142.   .bin_continue:
143.         dec     edi
144.         mov     byte[edi+4],"'"
145.         jmp     .bin_loop
146.   .bin_data:
147.         db      '0000','0001','0010','0011','0100','0101','0110','0111','1000','1001','1010','1011','1100','1101','1110','1111'
148.  
149. .hex:   lea     esi,[esp+4]
150.   .hex_loop:
151.         cld
152.         lodsb
153.         std
154.         mov     ah,al
155.         call    .daa
156.         stosb
157.         shr     eax,12
158.         call    .daa
159.         stosb
160.         dec     cl
161.         jnz     .hex_continue
162.         inc     edi
163.         cld
164.         invoke  SendDlgItemMessageA,[wnd],ebx,WM_SETTEXT,0,edi
165.         ret     0
166.   .hex_continue:
167.         mov     al,"'"
168.         stosb
169.         jmp     .hex_loop
170.   .daa: and     al,$0f
171.         add     al,$30
172.         daa
173.         cmp     al,$40
174.         sbb     al,$ff
175.         ret     0
176. endp
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. ;  Translate string into a tenbyte float.
220. ;  src          = string
221. ;  options      = bit 00..07: idle char
222. ;                 bit 08..08: 1 to avoid fpu, slow but exact
223. ;                             0 to use fpu, rapid but less exact
224. ;  ecx:ebx:eax <- result
225. ;  flags.cf    <- error
226. ;  fpu         <- FINIT if fpu mode used
227. ;*/
228. proc bsa_a2f; src, options
229.         stc                            ;error = 1
230.         pushf
231.         enter   +4 +12 +255+1,0        ;+4     = ?
232.                                        ;+12    = result(ecx:ebx:eax)
233.                                        ;+255+1 = bcd buffer(+255), bcd buffer.body_len(+1)
234.         push    esi
235.         xor     esi,esi
236.         or      esi,[ebp+3*4]
237.         jz      .pepsi                 ;src = 0
238.         movzx   eax,byte[esi-4]
239.         shl     eax,8
240.         jz      .pepsi                 ;src.body_len AND $ff = 0
241.         push    edi edx
242.  
243.         cld
244.         lea     edi,[esp+3*4]
245.         stosb                          ;bcd.body_len = 0
246.  
247. .load:  lodsb
248.         cmp     al,[ebp+4*4]
249.         je      .continue              ;options[0..7]
250.         cmp     al,'-'
251.         je      .sign
252.         cmp     al,'+'
253.         je      .sign
254.         cmp     al,'.'
255.         je      .dot
256.         cmp     al,','
257.         je      .dot
258.         cmp     al,'e'
259.         je      .exp
260.         cmp     al,'E'
261.         je      .exp
262.         sub     al,'0'
263.         cmp     al,9
264.         ja      .cola                  ;invalid char
265.         stosb
266.         inc     byte[esp+3*4]          ;inc bcd.body_len
267.         jmp     .continue
268. .sign:  cmp     byte[esp+3*4],0
269.         jnz     .cola                  ;'xxx.-x' etc
270.         bts     eax,30
271.         jc      .cola                  ;sign already specified
272.         shl     eax,1                  ;'-'=01'1101b, '+'=01'1011b
273.         shr     al,4
274.         rcr     eax,1
275.         jmp     .continue
276. .exp:   bts     eax,29
277.         jc      .cola                  ;exponent mode already ON
278.         mov     dword[ebp-4],.continue
279. .exp_:  push    eax esi
280.         call    .bcd2i                 ;get integer
281.         pop     esi edx
282.         jc      .cola                  ;over(64bits)flow | bcd.body_len = 0
283.         btr     edx,31                 ;get sign of integer
284.         call    i2f                    ;convert integer to float
285.         btr     edx,30                 ;entered exponent mode - allow signs again
286.         mov     [ebp-4-4],ecx
287.         mov     [ebp-4-4-4],ebx
288.         mov     [ebp-4-4-4-4],eax      ;store that float
289.         mov     eax,edx
290.         mov     dl,0
291.         xchg    dl,[edi-1]             ;bcd.body_len = 0
292.         bt      eax,28
293.         jnc     .tod
294.         shr     eax,8
295. ;!overflow protector begin
296.         sub     dl,ah
297.         mov     ah,dl
298. ;!overflow protector end
299.         shl     eax,8
300. .tod:   jmp     dword[ebp-4]
301. .dot:   bt      eax,29
302.         jc      .cola                  ;exponent must be integral
303.         bts     eax,28
304.         jc      .cola                  ;fraction already defined
305.         shr     eax,8
306.         mov     ah,[esp+3*4]           ;bcd.body_len
307.         shl     eax,8
308. .continue:
309.         dec     ah
310.         jnz     .load
311.  
312.         bt      eax,29
313.         jc      .mantissa_got          ;'e'/'E' detected and mantissa has been got
314.         xor     esi,esi                ;no 'e'/'E' detected
315.         mov     dword[ebp-4],.exp_got  ;dest. on success
316.         jmp     .exp_
317. .mantissa_got:
318.         movzx   ecx,byte[esp+3*4]
319.         cmp     cl,0
320.         jz      .cola                  ;exponent field undefined
321.         push    eax
322.         call    .bcd2i_
323.         pop     esi
324.         setc    cl
325.         cmp     dword[ebp-4-4-4],0
326.         jz      .load_float_integer    ;0 * 10^x = 0
327.         cmp     cl,1
328.         je      .cola                  ;exponent exceeds 64bits
329.         test    ebx,ebx
330.         jnz     .cola                  ;exponent is still too big
331.         cmp     eax,4'932+254
332.         ja      .cola                  ;exponent is still too big
333.         sub     ebx,eax
334.         test    esi,esi                ;know eax.31 responsible for value sign
335.         cmovs   eax,ebx                ;negative exponent
336.         xchg    esi,eax
337. .exp_got:
338.         shr     eax,8
339.         movzx   eax,ah
340.         sub     esi,eax                ;actual exponent got
341. .load_float_integer:
342.         mov     ecx,[ebp-4-4]
343.         mov     ebx,[ebp-4-4-4]
344.         mov     eax,[ebp-4-4-4-4]
345.         jz      .ok                    ;integral float e.g. 1.0
346.         test    ebx,ebx
347.         jz      .ok                    ;0.0 * 10^x = 0
348.         cmp     esi,-4931
349.         jl      .cola
350.         cmp     esi,4932
351.         jg      .cola
352.         ;;
353.         test    byte[ebp+4*4+1],1
354.         jnz     .avoid_fpu             ;simulate fpu
355.         finit
356.         push    esi
357.         fild    dword[esp]
358.         call    power10                ;10^esi
359.         push    ecx ebx eax
360.         fld     tbyte[esp]
361.         fmulp                          ;* intermediate integral float
362.         fxam
363.         fstsw   ax
364.         fstp    tbyte[esp]
365.         and     ah,01000101b           ;fpu.sw.{x|c3|x|x|x|c2|x|c0}
366.         cmp     ah,00000100b           ;fpu.sw.c2 =1= common number
367.         pop     eax ebx ecx esi
368.         jne     .cola
369.         jmp     .ok
370. .avoid_fpu:
371.         ;;
372.         lea     edx,[ecx*2]            ;hide sign bit to
373.         shr     dx,1                   ;operate easily
374.         test    esi,esi
375.         jns     .fp_mul                ;positive power
376. .fp_div:call    fp_div
377.         add     dx,cx
378.         jz      .cola                  ;non standard
379.         js      .cola                  ;non standard
380.         inc     esi
381.         jnz     .fp_div
382.         jmp     .fp_fin
383. .fp_mul:call    fp_mul
384.         add     edx,ecx
385.         cmp     dx,$7ffe
386.         ja      .cola                  ;non standard
387.         dec     esi
388.         jnz     .fp_mul
389. .fp_fin:shl     edx,1
390.         btr     edx,16+1
391.         rcr     dx,1
392.         mov     ecx,edx                ;result got
393.  
394. .ok:    dec     byte[ebp+4]            ;error = 0
395. .cola:  pop     edx edi
396. .pepsi: pop     esi
397.         leave
398.         popf
399.         ret     2*4
400.  
401. .bcd2i: movzx   ecx,byte[esp+12+3*4]
402.         cmp     cl,0
403.         jz      .bcd_fail              ;bcd.body_len = 0
404. .bcd2i_:push    0 0                    ;result
405. .bcd_load:
406.         dec     edi
407.         movzx   eax,byte[edi]
408.         cmp     al,0
409.         jz      .bcd_continue          ;0 * x = 0
410.         cmp     ch,0
411.         jnz     .bcd_power
412.         mov     [esp],al               ;x * 10^0 = x
413.         jmp     .bcd_continue
414. .bcd_power:
415.         cmp     ch,19
416.         jna     .bcd_power_
417. .bcd_fail_:                            ;over(64bits)flow
418.         add     esp,2*4
419. .bcd_fail:
420.         stc                            ;error = 1
421.         ret     0
422. .bcd_power_:
423.         mov     esi,ecx
424.         xor     ebx,ebx
425. .bcd_power__:
426.         push    ecx
427.         mov     ecx,10
428.         call    _64mul32
429.         pop     ecx
430.         jnz     .bcd_fail_             ;over(64bits)flow
431.         dec     ch
432.         jnz     .bcd_power__
433.         add     [esp],eax
434.         adc     [esp+4],ebx
435.         jc      .bcd_fail_             ;over(64bits)flow
436.         mov     ecx,esi
437. .bcd_continue:
438.         inc     ch                     ;power of ten
439.         dec     cl                     ;digits left
440.         jnz     .bcd_load
441.         pop     eax ebx
442.         clc                            ;error = 0
443.         ret     0
444. endp
445.  
446.  
447.  
448.  
449. ; normalized mantissa -> ebx:eax
450. ; ebx:eax             <- if fp_div: normalized (mantissa * 0.1)
451. ;                        if fp_mul: normalized (mantissa * 10.0)
452. ; ecx                 <- exponent delta
453. ; flags               <- ?
454. proc fp_div
455.         push    edx
456.         mov     edx,$cccc'cccc
457.         mov     ecx,$cccc'cccd
458.         call    _64mul64        ; 0.1 = $3ffb'cccccccc'cccccccd, exp = -4
459.         mov     eax,ecx
460.         bsr     ecx,edx
461.         neg     ecx
462.         add     ecx,31
463.         shld    edx,eax,cl
464.         shld    eax,ebx,cl
465.         mov     ebx,edx
466.         pop     edx
467.         neg     ecx
468.         sub     ecx,3           ; -63*2 -4 +64 +64 -1 =-3
469.         ret     0
470. endp
471. ; fasm internals simulator
472. proc fp_mul
473.         push    edx
474.         mov     edx,$a000'0000
475.         xor     ecx,ecx
476.         call    _64mul64        ; 10.0 = $4002'a0000000'00000000, exp = +3
477.         mov     eax,ecx
478.         bsr     ecx,edx
479.         neg     ecx
480.         add     ecx,31
481.         shld    edx,eax,cl
482.         shld    eax,ebx,cl
483.         mov     ebx,edx
484.         pop     edx
485.         neg     ecx
486.         add     ecx,4           ; -63*2 +3 +64 +64 -1 =4
487.         ret     0
488. endp
489.  
490.  
491.  
492.  
493. ; edx:ecx:ebx:eax <- edx:ecx * ebx:eax = (edx*ebx:eax) shl 32 + ecx*ebx:eax
494. ; flags           <- result.edx + 0
495. ;
496. ; $ffffffff'ffffffff * $ffffffff'ffffffff = $ffffffff'ffffffff * $1'00000000'00000000 - $ffffffff'ffffffff = $ffffffff'ffffffff'00000000'00000000 - $ffffffff'ffffffff = $ffffffff'fffffffe'00000000'00000001 = 128bit
497. proc _64mul64
498.         push    ecx ebx eax
499.         mov     ecx,edx
500.         call    _64mul32
501.         xchg    ecx,[esp+8]
502.         xchg    ebx,[esp+4]
503.         xchg    eax,[esp]
504.         call    _64mul32
505.         pop     edx
506.         add     ebx,edx
507.         pop     edx
508.         adc     ecx,edx
509.         pop     edx
510.         adc     edx,0
511.         ret     0
512. endp
513.  
514.  
515.  
516.  
517. ; ecx:ebx:eax <- ecx * ebx:eax = (ecx*ebx) shl 32 + ecx*eax
518. ; edx         <- ecx*eax
519. ; flags       <- result.ecx + 0
520. ;
521. ; $ffffffff'ffffffff * $ffffffff = $ffffffff'ffffffff * $1'00000000 - $ffffffff'ffffffff = $ffffffff'ffffffff'00000000 - $ffffffff'ffffffff = $fffffffe'ffffffff'00000001 = 96bit
522. proc _64mul32
523.       xchg    ebx,eax
524.       mul     ecx
525.       xchg    ebx,eax
526.       xchg    edx,ecx
527.       mul     edx
528.       add     ebx,edx
529.       adc     ecx,0
530.       ret     0
531. endp
532.  
533.  
534.  
535.  
536. ; integer     -> ebx:eax
537. ; result.79   -> flags.cf
538. ; flags.cf    <- 1 if zero
539. ; ecx:ebx:eax <- tbyte float
540. ;
541. ; example:
542. ;   or      eax,-1
543. ;   or      ebx,-1
544. ;   clc
545. ;   call    i2f    ; ecx:ebx:eax = $3fff+63'ffffffff'ffffffff = +18'446'744'073'709'551'615
546. ;   or      eax,-1
547. ;   or      ebx,-1
548. ;   stc
549. ;   call    i2f    ; ecx:ebx:eax = $bfff+63'ffffffff'ffffffff = -18'446'744'073'709'551'615
550. proc i2f
551.         pushf
552.         xor     ecx,ecx
553.         cmp     ebx,ecx
554.         jnz     .hnz
555.         cmp     eax,ecx
556.         jnz     .lnz
557.         bts     dword[esp],0
558.         jmp     .sign
559. .lnz:   xchg    ebx,eax
560.         sub     ecx,32
561. .hnz:   push    edx
562.         bsr     edx,ebx
563.         neg     edx
564.         add     edx,31
565.         neg     edx
566.         lea     ecx,[$3fff+63+ecx+edx]
567.         neg     edx
568.         xchg    cl,dl
569.         shld    ebx,eax,cl
570.         shl     eax,cl
571.         mov     cl,dl
572.         pop     edx
573.         shl     ecx,1
574.         btr     dword[esp],0
575. .sign:  rcr     cx,1
576.         popf
577.         ret     0
578. endp
579.  
580.  
581.  
582.  
583. ;power   -> st0
584. ;st0     <- 10^power
585. ;fpu.tos <- returned
586. ;ensure st5..st7 are free before calling this proc
587. proc power10
588.                        ;10^power=2^x
589.                        ;x=log(2;10^power)=log(2;10)*power
590.         fldl2t         ;log(2;10)
591.         fmulp          ;x
592.  
593.                        ;2^x=2^x.fraction*2^x.whole=2^x.fraction shl x.whole
594.         fld     st0    ;x
595.         frndint        ;x.whole
596.         fsub    st1,st0;x.fraction
597.         fxch
598.         f2xm1          ;2^x.fraction -1
599.         fld1
600.         faddp          ;2^x.fraction
601.         fscale         ;shl x.whole
602.         fstp    st1    ;10^x
603.         ret     0      ;-)
604. endp

 

edemko,Спасибо за помощь!

 

rozz, все в порядке.

Тема меня трет, продолжу...
Благодаря угадайте кому выяснилось, что обход fpu был негладкий - примерно так выглядит поправка.
Если интересно, за этой ссылкой лежит интерфейсная часть, а за этой сам код.

В файле "\80 bit floats\rozz\rozz.theory - ru.asm" расписано получение дроби.
Хотелось проделать в Excel, но тот(!) выдавал не точный результат.
И так, вот она, автомата.

 

нужна срочно помощь прога желательно в делфи


дана символьная матрица. характеристикой строки назовем длину,содержащейся в ней максимальной серии. Определитьномер строки,имеющей наибольшую характеристику.

 

Код (Text):

1. function GetCharacteristics(Str:String):Longword;
2. begin
3.   //Вычисление максимальной серии в строке. Смотря что вы хотите посчитать.
4. end;
5.  
6. const
7.   LinesCount = 10240;
8.  
9. var
10.   Str:array of Srring;
11.   Cur:Longword;
12.   Num:Longword;
13.   Max:Longword;
14.   Ind:Longword;
15.  
16. begin
17.   SetLength(Str, LinesCount);
18.   for Ind:=Low(Str) to High(Str) do Str[Ind]:=InputString('Введите строку номер '+inttostr(Ind));
19.   Cur:=GetCharacteristics(Str[Low(Str)]);
20.   Num:=0;
21.   for Ind:=Low(Str)+1 to High(Str) do
22.   begin
23.     Cur:=GetCharacteristics(Str[Ind]);
24.     if Max<Cur then
25.     begin
26.       Num:=Ind;
27.       Max:=Cur;
28.     end;
29.   end;
30.   ShowMessage('Строка с максимальной характеристикой номер '+inttostr(Num));
31. end.

Но до рабочего состояния доводите сами.

 

Проблема с выводом числа типа word.

Число в ax.

Код (Text):

1. .model small
2.  
3. .code
4. mov ax,344
5. mov bx,10
6. mov cx,0
7.  
8. m1:
9. mov dx,0
10. div bx
11. inc cx
12. push dx
13. cmp ax,0
14. jne m1
15. mov ah,2
16. m2:
17. pop dx
18. add dl,30h
19. int 21h
20. loop m2
21.  
22.  
23. mov ah,4Ch
24. int 21h
25.  
26. end m1

Пишет Devide Overflow

Подскажите в чем проблема!!

 

bor1k
Проблема в том что 3 в 344 меньше чем 10 на которую делишь.
Сравнивай ax не с 0 а проверяй на < 10 и первую цифру печатай из ax а не из стека.
Вот ещё ознакомься для общего развития

 

а куда мне сохранить первую цифру? если вывод цифр идет наооборот

 

О сделал)

Код (Text):

1. .model small
2.  
3. .code
4. start:
5.  
6. mov ax,32439
7. mov bx,10
8. mov cx,0
9.  
10. m1:
11.  
12. mov dx,0
13. div bx
14. inc cx
15. push dx
16. cmp ax,10
17. jnc m1
18. mov ah,2
19. mov dl,al
20. add dl,30h
21. int 21h
22. m2:
23. pop dx
24. add dl,30h
25. int 21h
26. loop m2
27.  
28.  
29. mov ah,4Ch
30. int 21h
31.  
32. end start

 

я обычно пользуюсь этим

Код (Text):

1. push bp
2. mov bp, sp
3. sub sp, 18
4. dec bp
5. mov byte [bp], 0
6. mov cx, 10; если функция не должна принимать основание системы счиления как параметр
7. @@lp:
8. xor dx, dx
9. div cx
10. dec bp
11. mov dh, dl
12. add dl, 48
13. cmp dl, 10
14. jc @@ok
15. add dl, 7
16. @@ok:
17. mov [bp], dl
18. test ax, ax
19. jnz @@lp
20. call @@cp
21. add sp, 18
22. pop bp
23. retn
24. @@cp:
25. xor ah, ah
26. jmp @@bg
27. @@cl:
28. mov al, [bp]
29. stosb
30. inc bp
31. @@bg:
32. cmp [bp], ah
33. jnz @@cl
34. retn

не очень оптимально, но для 16-бит пойдет. еще можно оценить это

Код (Text):

1. ; ax=XXXXX
2. mov cx, 10
3. xor dx, dx
4. div cx
5. ; ax=XXXX
6. mov bl, dl
7. xor dx, dx
8. div cx
9. ; ax=XXX
10. mov bh, dl
11. xor dx, dx
12. div cx
13. ; ax=XX
14. mov ch, dl
15. xor ah, ah
16. div cl
17. ; bl=младшая цифра
18. ; bh=цифра чуть старше предыдущей
19. ; ch=средняя цифра
20. ; ah=цифра чуть младше следующей
21. ; al=старшая цифра