calculatrice en assembleur

Version imprimable

25/05/2012, 19h06
goldenprincess

calculatrice en assembleur

Bonjour,
je suis débutante en assembleur et j'ai besoin d'un code source d'une calculatrice qui réalise les opérations arithmétique (+,-,*,/)et qui gère les priorités, les parenthèses
cela fait 3 nuits blanches que je passe et je n'arrive pas à m'en sortie .
Merci d'avance
ps:j'utilise emu8086
25/05/2012, 22h16
bifur

emu8086, je suppose qu'il s'agit d'un devoir?
comment fait on l'acquisition des données a calculer? est ce une ligne de commande?
est ce que l'on peut utiliser la notation polonaise inversé? (http://fr.wikipedia.org/wiki/Notation_polonaise_inverse)
les nombres intervenant dans le calcul sont il seulement des entiers?
qu'est ce qui a déja été fait au bout de 3 nuit blanche?
25/05/2012, 23h42
goldenprincess

Tout d’abord merci pour votre réponse .
pour l'acquisition des données a calculer l'utilisateur entre l'expression arithmétique qui veut calculer et le programme affiche le résultat
dans ce programme en manipule que des entiers sans utiliser la notation polonaise inversé
26/05/2012, 13h51
bifur

pas de NPI? c'est dommage. même s'il n'y as que des entier ça me semble un peu difficile de demander ça a des débutants en assembeur

je n'ai jamais eu ce genre de probleme a résoudre donc dans l'immédiat je ne pourrait pas y répondre mais je pense que le NPI est une bonne piste pour y répondre car dans l'article wikipédia on parle d'une méthode pour convertir l'expression standard d'un calcul en une expression NPI (qui du coup sera plus facile a calculer pour un ordinateur)

nb: en général les gens ne répondent plus facilement a ce genre de post si l'auteur nous parle des pistes qu'il a suivi
27/05/2012, 21h32
goldenprincess

mrci pour ton passage :) mais comment peut-on transformer une expression standard d'un calcul en une expression NPI avec le langage machine de bas niveau ça parait un peu difficile n'est ce pas 8O
27/05/2012, 23h48
bifur

difficile mais pas impossible, courage! :ccool:

j'essaye aussi de mon coté de faire la conversion standard->npi d'une chaine de caractère a une autre
j'en suis a une toute petite centaine de ligne, le résultat finale devrais faire a mon avis environs 200 lignes

comme ça je pourrait installer un fonction calculatrice sur mon os

voila c'est fait, j'ai créer un petit prog de calcul
celui ci fonctionne en ligne de commande, il s'appel npi.com et est compilé par fasm
il suffit de rentrer la commande : npi(un espace)(l'expression a calculer)
il convertie l'expression a calculer en une expression en notation polonaise inversé (et l'affiche) puis calcul le résultat (et l'affiche aussi)

Code:

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
 
org 100h
mov ax,cs
mov ds,ax
mov es,ax
xor dx,dx
mov fs,dx
 
mov bx,82h
mov di,npiconv
mov [sauvesp],esp
 
bcdef:
mov al,[bx]
cmp al,"*"
je fois
cmp al,"+"
je plus
cmp al,"/"
je divise 
cmp al,"-"
je moins
cmp al,"0"
je chiffre
cmp al,"1"
je chiffre
cmp al,"2"
je chiffre
cmp al,"3"
je chiffre
cmp al,"4"
je chiffre
cmp al,"5"
je chiffre
cmp al,"6"
je chiffre
cmp al,"7"
je chiffre
cmp al,"8"
je chiffre
cmp al,"9"
je chiffre
 
cmp al,"."
je point
cmp al,","
je point
cmp al,"("
je paranthese1
cmp al,")"
je paranthese2
jmp fin
 
chiffre:
mov [di],al
inc di
inc bx
jmp bcdef
 
point:            ;point ou virgule on enregistre un point dans la chaine de sortie
mov byte[di],"."
inc di
inc bx
jmp bcdef
 
divise:            ;signe divise, on v‚rifie qu'un multiplication n'est pas en haut de la pile
cmp esp,[sauvesp]
je pilevide
pop dx
cmp dl,"*"
je lkp 
jmp norm
 
plus:           ;signe  - ou + on verifie qu'il n'y a pas
moins:
cmp esp,[sauvesp]
je pilevide
pop dx
cmp dl,"*"
je lkp 
cmp dl,"/"
je lkp 
norm:
push dx
fois:  
pilevide:
push ax
mov al," "
mov [di],al 
inc di
inc bx
jmp bcdef
 
 
lkp:
push ax
mov dh," "
mov [di],dh 
inc di
mov [di],dl 
inc di
mov [di],dh 
inc di
inc bx
jmp bcdef
 
 
 
paranthese1:
push ax
mov al," "
mov [di],al 
inc di
inc bx
jmp bcdef
 
paranthese2:
inc bx 
bcdepp2:
cmp esp,[sauvesp]
je erreur
pop ax
cmp al,"("
je bcdef
mov ah," "
mov [di],ah 
inc di
mov [di],al 
inc di
mov [di],ah 
inc di
jmp bcdepp2
 
erreur:
mov ah,09h
mov dx,msgerreur
int 21h
mov ax,4C00h
int  21h
 
 
fin:
cmp esp,[sauvesp]     ;d‚pile tout les op‚rateur restant
je okay
pop ax
je bcdef
mov ah," "
mov [di],ah 
inc di
mov [di],al 
inc di
jmp fin
 
okay:
mov byte[di],"$"
mov ah,09h
mov dx,npiconv
int 21h
 
mov bx,npiconv   
 
boclcnpi:
mov al,[bx]
cmp al,"*"
je foisnpi
cmp al,"+"
je plusnpi
cmp al,"/"
je divisenpi 
cmp al,"-"
je moinsnpi
cmp al,"0"
je chiffrenpi
cmp al,"1"
je chiffrenpi
cmp al,"2"
je chiffrenpi
cmp al,"3"
je chiffrenpi
cmp al,"4"
je chiffrenpi
cmp al,"5"
je chiffrenpi
cmp al,"6"
je chiffrenpi
cmp al,"7"
je chiffrenpi
cmp al,"8"
je chiffrenpi
cmp al,"9"
je chiffrenpi
cmp al,"$"
je finpi
inc bx
jmp boclcnpi
 
foisnpi:
pop ecx
pop eax
xor edx,edx
mul ecx
push eax
inc bx
jmp boclcnpi
 
divisenpi:
pop ecx
pop eax
xor edx,edx
div ecx
push eax
inc bx
jmp boclcnpi
 
moinsnpi:
pop ecx
pop eax
sub eax,ecx
push eax
inc bx
jmp boclcnpi
 
plusnpi:
pop ecx
pop eax
add eax,ecx
push eax
inc bx
jmp boclcnpi
 
chiffrenpi:
xor edx,edx
bochifnpi:
mov al,[bx]
cmp al," "
je findecod
sub al,"0"
and eax,0Fh
mov ecx,edx
shl edx,3
shl ecx,1
add edx,ecx
add edx,eax
inc bx
jmp bochifnpi
 
findecod:
push edx
inc bx
jmp boclcnpi
 
 
finpi:
mov ah,09h
mov dx,msgligne
int 21h
 
 
pop eax
call deci32
 
mov ax,4C00h
int  21h
 
msgligne:
db 10,13,"$"
sauvesp:
dd 0
msgerreur:
db "erreur$"
npiconv:
dd 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 
atclav:
mov ah,0
int 16h
cmp al," "
jne atclav
ret
 
 
ztdeci:
dd 0,0,0,0,0
 
deci32:
push eax
push ecx
push edx
push si
 
mov si,ztdeci+11
mov cl,"$"
mov [si],cl
mov ecx,10
 
bd32:
xor edx,edx
div ecx
add dl,48
dec si
mov [si],dl
cmp si,ztdeci
jne bd32
 
dec si
ajust:
inc si
mov al,[si]
cmp al,"0"
je ajust
cmp al,0
jne nzer
dec si
nzer:
mov dx,si
mov ah,09h
int 21h
 
pop si
pop edx
pop ecx
pop eax
ret
 
bcd:
push ax
push dx
push cx
mov ch,al
and al,0Fh
add al,48 
cmp al,57 
jle suit
add al,7
suit:
mov ah,0Eh
push ax
mov al,ch
and al,0F0h
mov cl,4
shr al,cl
add al,48
cmp al,57 
jle suitc
add al,7
suitc:
push ax
mov bl,10
pop ax
int 10h
pop ax
int 10h
pop cx
pop dx
pop ax
ret
 
ZT:

c'est pas parfait (limité aux entiers positifs, les calculs sont tronqué a chaque opération) et non commenté mais ça fait grosso merdo ce que vous demandez

Salut,

Merci pour tes efforts mais ton programme ne marche pas. Je ne sais pas pourquoi (rq :j utilise emu8086) moi aussi j'ai fait un programme d'une calculatrice. Il fait des calculs (nombres réels et entiers) sans tenir compte de la priorité des opérations mais il y a quelque petits problèmes : il n'accepte pas la division de 10 par 1, 11 par 1 et 12 par 1 et aussi il n'accepte pas une expression comme celle ci : -8+4 il n'affiche pas le résultat. Par contre si j'introduis cette expression il l'accepte 4-8 et il affiche le resultat -4 . et aussi j'ai essayé de faire une boucle qui m'affiche une erreur si l'utilisateur divise un nombre par 0 mais ça na pas marché est ce que vous pouvez m'indiqué les erreurs et me les corrigé (j'utilise emu8086 /32bits)

voici le code source :

Code:

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
 ecrire macro char
                  lea dx,char
                   mov ah,9            ;macro qui ecrit une chaine
                  int 33
              ecrire endm
 
              positionne macro lig,col
                  mov dh, lig
                  mov dl, col                       
                  mov bh, 0          
                  mov ah, 2    ;cursor position
                  int 10h
              positiionne endm
 
              clear_screen macro
                  pusha
                  mov ax, 0600h
                  mov bh, 0000_1111b   ;macro qui efface l'ecran
                  mov cx, 0
                  mov dh, 24
                  mov dl, 79
                  int 10h
                  popa
              clear_screen endm
;-----------------------------------------------------
              donnee    segment 'data'
 
                new_line        db       0Dh,0Ah, '$'
                tiree           db      "-----------------------------------------------$"
                mess0           db      "merci de votre patience $"
                mess1           db      "entrer le dexieme nombre $"
                demande         db      "entrer une expression numerique quelconque $"
                ask             db      "appuyer sur 1 pour recalculer et sur 0 pour quitter $"
                chaine db 100 dup(0)
                tab1 db 100 dup(0)
                tab2 db 100 dup(0)
                tab1dec db 100 dup(0)
                tab2dec db 100 dup(0)
                tabinv db 100 dup(0) 
                tab1op db 100 dup(0)
                tab2op db 100 dup(0)
                tab1div db 100 dup(0)
                tab2div db 100 dup(0)
                tabresult db 100 dup(0)
                operation db 0
                operation2 db 0
                moins db 0
                inf db 0
                egale db 0
                decalage dw 0
                read dw 0
                test_multiplication dw 0
                virgule1 dw 0
                virgule2 dw 0
                zero1 dw 0
                zero2 dw 0
                zero11 dw 0
                zero22 dw 0
                retenue dw 0
                non_vir dw 0
                vir dw 0
                virdivision dw 0
                dir dw 0
                infzero dw 0
                dir2 dw 0
                sir dw 0
                sir2 dw 1
                bxr dw 0
                axr dw 0
                signe db 0
                result dw 0
                cxr dw 0
                teste dw 0 
                dont_print db 0
 
              donnee    ends
      ;------------------------
               sseg    segment stack   'stack'
               dw      20    dup(?)
               sseg    ends
      ;------------------------------------
               cseg    segment 'code'
               start:
                    ; set segment registers:
                  mov     ax, donnee
                  mov     ds, ax
                  mov     es, ax
             ;------------------------------------
               clear_screen
                  recalculer:positionne 0,0
                  ecrire tiree
                  ecrire new_line
                  ecrire demande
                  ecrire new_line
                  ecrire tiree
                  positionne 3,0
                  call remplit_chaine 
                  ecrire new_line 
                  mov si,0
                  call calcul
                  ecrire ask
                  call scan
                  cmp al,31h
                  jne finished 
                  clear_screen
                  call initialise_tous
                  call initialise_variable
                  jmp recalculer
         finished:
                  mov ah,1
                  int 21h
;--------------------------------------------------------
;************ les procedures utilisées*********************
;------------------------------------------------------------
 
              ;procedure qui scan un caractere
                scan proc
                  mov ah,1
                  int 21h
                  ret
                scan endp
;-------------------------------------------------------------
              ;procedure  qui ecrit un caractere
                printchar proc
                  mov dl,al
                  mov ah,2
                  int 21h
                  ret
                printchar endp
;-------------------------------------------------------------
;procedure qui range la chaine dans tabchaine
remplit_chaine proc
mov si,0
rem:call scan
cmp al,0dh    ;teste la  touche enterer
je fin
mov chaine[si],al
inc si
jmp rem
fin:ret
remplit_chaine endp
;--------------------------------------------------------------
;procedure qui affiche la chaine situe dans tabchaine
ecrire_chaine proc
mov cx,si
ecr: mov al,chaine[si]
call printchar
inc si
loop ecr
ret
ecrire_chaine endp
;----------------------------------------------------------
initialise_tous proc
mov cx,100
mov di,0
mov al,0
tout_initialise:mov chaine[di],al
mov tab1[di],al
mov tab2[di],al
mov tab1dec[di],al
mov tab2dec[di],al
mov tab1op[di],al
mov tab2op[di],al
mov tabinv[di],al
mov tab1div[di],al
mov tab2div[di],al
mov tabresult[di],al
inc di
loop tout_initialise
ret
initialise_tous endp
;-----------------------------------------
initialise_variable proc
mov operation,0
mov operation2,0
mov moins,0
mov inf,0
mov egale,0
mov decalage,0
mov read,  0
mov test_multiplication,0
mov virgule1,0
mov virgule2,0
mov zero1,0
mov zero2,0
mov zero11,0
mov zero22,0
mov retenue,0
mov non_vir,0
mov vir,0
mov virdivision,0
mov dir,0
mov infzero,0
mov dir2,0
mov sir,0
mov sir2,1
mov bxr,0
mov axr,0
mov signe,0
mov result,0
mov cxr,0
mov teste,0
mov dont_print,0
ret
initialise_variable endp
 
 
;--------------------------------------------------------------
;proicedure qui affiche le contenu de tab1
print_tab1 proc
mov al,61
call printchar
mov di,99
cmp tab1[di],0fbh
je dont_write
mov al,tab1[di]
add al,30h       ;afficher le signe
call printchar
 
dont_write:dec di
zero_al:cmp tab1[di-1],0fch
je ecriture_tab
cmp di,-1
je fin_ecriture
mov al,tab1[di]
cmp al,0
jne di_trouv:
dec di
jmp zero_al
di_trouv:add di,infzero
ecriture_tab:mov al,tab1[di]
add al,30h                
call printchar
cmp di,0
je fin_ecriture
dec di
jmp ecriture_tab
 
fin_ecriture:mov di,sir2
sub di,2
ec:  cmp chaine[di],0
je qq
mov al,chaine[di]
call printchar
inc di
jmp ec
qq: ret
print_tab1 endp
;--------------------------------------------------------------
;procedure qui initialise tab2 a 0
initialise2 proc
mov cx,99
mov di,0
cc2:mov tab2[di],0
inc di
loop cc2
ret
initialise2 endp
;---------------------------------------------------------------
;procedure qui initialise tab1 a 0
initialise proc
mov cx,99
mov di,0
initiali:mov tab1[di],0
inc di
loop initiali
ret
initialise endp
;---------------------------------------------------------------
;procedure qui donne le premir element non nul de tab1 et tab2
compare proc
mov di,99
supinf:cmp di,0
je rr
dec di
mov al,tab1[di]
cmp al,0
jne rr
cmp al,tab2[di]
je supinf
rr:add di,1
mov cxr,di
ret
compare endp
;---------------------------------------------------------------
;procedure qui donne l ordre de tab1 et tab2
compare2 proc
mov cx,99
mov di,98
kkk:mov al,tab1[di]
cmp al,tab2[di]
jl lower
ja above
dec di
loop kkk
mov egale,1
lower:mov inf,1
jmp qr
above:mov inf,0
qr:ret
compare2 endp
 
;---------------------------------------------------------------
find_di proc
mov di,98
search_di:cmp di,0
je di_found
mov al,tab1[di]
cmp al,0
jne di_found
dec di
jmp search_di
di_found:ret
find_di endp
;-----------------------------------------------------------------
;procedure qui fait le calcul en cours
calcul proc
calculer:mov si,sir2
dec si
mov di,si
com:mov al,chaine[si]
mov dir2,ax
and al,00110000b      ;tester si c'est un nombre
cmp al,00110000b
jne test_virgule
mov al,chaine[si]
cwd
push ax
inc si
jmp com
test_virgule: mov ax,dir2
inc si
push ax
cmp al,2ch
je com
pop ax
empile_operation:
cmp al,0                ;sauvgarde l operation prochaine
jne sauv_operation
mov teste,1             ;et verifie si la chaine est terminer
sauv_operation:mov al,chaine[si-1]
mov operation,al
mov ax,si               ;axr recoit la longueur
sub ax,di
mov axr,ax
mov read,ax               ;de l operation en cours
inc si
mov cx,ax
dec cx               ;range les l operande en cours
mov di,0                ;dans tab2
pop1: pop bx
sub bl,30h
mov tab2[di],bl
inc di
loop pop1
mov dir2,di
mov sir2,si
call elimin_virgule
 
 
;-----------------------------------choisir une operations
cmp operation2,0
jne non_verser
call verser
jmp suite
non_verser:mov di,99
cmp operation2,43
jne non_addition
cmp tab1[di],0fbh
jne soustr
call addition
jmp suite
non_addition:cmp operation2,45
jne non_sustraction
cmp tab1[di],0fbh
je soustr
call scan
call addition
jmp suite
soustr: call sustraction
non_sustraction:cmp operation2,42
jne non_multiplication
call multiplication
mov ax,1
mov test_multiplication,ax
non_multiplication:
cmp operation2,47
jne non_division
call division
;-----------------------------------------------------
non_division:
suite:
call initialise2
cmp test_multiplication,1
jne non_multip
mov ax,vir                ;test multiplication pour virgule
mov bx,2
mul bx
mov vir,ax
 
 
non_multip:call withvirgule
mov test_multiplication,0  ;reinstialise 
cmp dont_print,1
je dont_print_it
call print_tab1 
dont_print_it:
mov dont_print,0
ecrire new_line
cmp teste,1          ;verifie si la chaine est terminer
je fin_calcul
mov al,operation
mov operation2,al
call initialise2
jmp calculer
fin_calcul:
ret
calcul endp
;---------------------------------------
;-----------procedures de calcul------
;---------------------------------------
elimin_virgule proc
mov di,0              ;on donne la position de virgule1
search_vir_tab1:mov al,tab1[di]
cmp al,0fch
je virgule_1op_found
inc di
cmp di,99
jne search_vir_tab1
mov ax,0
mov virgule1,ax
jmp recherche_zero_tab1
;--------------------------------------------------------------
virgule_1op_found:
mov virgule1,di
recherche_zero_tab1:
mov di,98
search_zero_tab1:cmp tab1[di-1],0fch
je zero_tab1_found
cmp di,0
je zero_tab1_found
; on donne zero1
cmp tab1[di],0
jne zero_tab1_found
dec di
jmp search_zero_tab1
zero_tab1_found:mov zero11,di
;----------------------------------------------------------
mov di,0              ;on donne la position de virgule2
search_vir_tab2:
mov al,tab2[di]
cmp al,0fch
je virgule_2op_found
inc di
cmp di,99
jne search_vir_tab2
mov ax,0
mov virgule2,ax
jmp recherche_zero_tab2
;--------------------------------------------------------------
virgule_2op_found:
mov virgule2,di
recherche_zero_tab2:
mov di,98
search_zero_tab2:cmp tab2[di-1],0fch
je zero_tab2_found
cmp di,0
je zero_tab2_found
; on donne zero2
cmp tab2[di],0
jne zero_tab2_found
dec di
jmp search_zero_tab2
zero_tab2_found:mov zero22,di
;-------------------------------------------------------------------------
jner:mov ax,virgule1       ;les positions apres la virgule est dans vir
mov bx,virgule2
cmp ax,bx
jl prend_virgule2
mov vir,ax
jmp carry_on
prend_virgule2: mov vir,bx
 
;---------------------------------------------------
carry_on:mov cx,99
mov di,0
mov al,0
initialis:mov tab1dec[di],al
mov tab2dec[di],al           ;initialise les tt
inc di
loop initialis               ;tab1dec et tab2dec
;--------------------------------------------------
cmp vir,0
je pas_de_virgule    ;teste si il y a pas de virgule
;-------------------------------------------------------------
mov non_vir,0             ;ranger la parie decimal
;---------------------------------
mov ax,vir
cmp ax,virgule1                              ;teste si vir est virgule1
jne on_met_zero_op1
;-------------------------------------------------
mov cx,vir
mov di,0               ;on push la virgule1
rang_vir_op1: mov al,tab1[di]
push ax
inc di
loop rang_vir_op1
;------------------------------------------
mov cx,vir
dec di
jmp rangdec1:
;---------------------------------------------
on_met_zero_op1: mov cx,vir
sub cx,virgule1           ;on range les zeros
mov di,0
rang_vir_op1_zero:mov al,0
push ax
inc di
loop rang_vir_op1_zero
;-----------------------------------------------
cmp virgule1,0
je pas_de_reste
mov dir,di
mov di,0
mov cx,virgule1
rang_rest_op1: mov al,tab1[di]
push ax
inc di                ;on range le reste de virgule1
loop rang_rest_op1
add di,dir
jmp ranger_dans_tab1dec
pas_de_reste:  mov non_vir,1
ranger_dans_tab1dec:
dec di
mov cx,vir    ;on a ranger la partie decimale
rangdec1:  pop ax
mov tab1dec[di],al
dec di
loop rangdec1
;----------------------------------------------------
mov cx,zero11        ;cx donne le nombre de nombre entieres
sub cx,virgule1
add cx,non_vir
mov si,vir      ;si positionne le tab a ranger
inc si
mov di,virgule1
inc di              ;di positionne le tab1
sub di,non_vir
rangent1: mov al,tab1[di]
push  ax                  ;on a ranger la parie entiere
inc di
inc si
loop rangent1
;-------------------------------------------
mov cx,zero11
sub cx,virgule1
add cx,non_vir
;------------------------------------------
sub si,2
rangentp1:   pop ax                        ;on range la partie entiere
mov tab1dec[si],al
dec si
loop rangentp1
;------------------------------------------------------------------------
;    tab2
mov non_vir,0
mov ax,vir
cmp ax,virgule2         ;teste si vir est virgule2
jne on_met_zero_op2
;-------------------------------------------------
mov cx,vir
mov di,0               ;on push la virgule1
rang_vir_op2:  mov al,tab2[di]
push ax
inc di
loop rang_vir_op2
;------------------------------------------
mov cx,vir
dec di
jmp rangdec2:
;---------------------------------------------
on_met_zero_op2: mov cx,vir
sub cx,virgule2           ;on range les zeros
mov di,0
rang_vir_op2_zero:mov al,0
push ax
inc di
loop rang_vir_op2_zero
;-----------------------------------------------
cmp virgule2,0
je pas_de_reste2
mov dir,di
mov di,0
mov cx,virgule2
rang_rest_op2: mov al,tab1[di]
push ax
inc di                ;on range le reste de virgule2
loop rang_rest_op2
add di,dir
jmp ranger_dans_tab2dec
pas_de_reste2:  mov non_vir,1
ranger_dans_tab2dec:
dec di
mov cx,vir    ;on a ranger la partie decimale
rangdec2:  pop ax
mov tab2dec[di],al
dec di
loop rangdec2
;----------------------------------------------------
mov cx,zero22        ;cx donne le nombre de nombre entieres
sub cx,virgule2
add cx,non_vir
mov si,vir      ;si positionne le tab a ranger
inc si
mov di,virgule2
inc di              ;di positionne le tab2
sub di,non_vir
rangent2: mov al,tab2[di]
push  ax                  ;on a ranger la parie entiere
inc di
inc si
loop rangent2
;-------------------------------------------
mov cx,zero22
sub cx,virgule2
add cx,non_vir
;------------------------------------------
sub si,2
rangentp2:   pop ax                        ;on range la partie entiere
mov tab2dec[si],al
dec si
loop rangentp2
;------------------------------------------------------------------------
mov non_vir,0
;-----------------------------------------------------------------------
mov cx,98
mov di,0
ikj:   mov al,tab1dec[di]
mov bl,tab2dec[di]
mov tab1[di],al                   ;on copier les tableaux
mov tab2[di],bl
inc di
loop ikj
pas_de_virgule: ret
elimin_virgule endp
;----------------------------------------------------------
withvirgule proc
mov di,0     ;pas de virgule
cmp vir,0
je pas_virgule
kgf:   cmp di,vir
je  virgule_trouv
mov al,tab1[di]
mov tab2[di],al
inc di
jmp kgf
virgule_trouv:mov tab2[di],0fch
mov si,di
inc di
mov cx,98
sub cx,di
dec cx
mpo:   mov al,tab1[si]
mov tab2[di],al
inc di
inc si
loop mpo
jmp fin_withvirgule
pas_virgule:mov cx,98
mov di,0
by:mov al,tab1[di]
mov tab2[di],al
inc di
loop by
fin_withvirgule: mov cx,98
mov di,0
rem_ta21:mov al,tab2[di]
mov tab1[di],al
inc di
loop rem_ta21
ret
withvirgule endp
 
;--------------------------------------------------
verser proc
mov di,99
mov tab1[di],0fbh
mov cx,read
mov di,0
ver:  mov al,tab2[di]
mov tab1[di],al
inc di
loop ver
call compare 
mov dont_print,1
ret
verser endp
;--------------------------------------------------------------
addition proc
mov di,0
mov cx,99
add cx,1
go:  mov al,tab1[di]
add al,tab2[di]
cmp al,10
jnge nge
sub al,10
add tab1[di+1],1 ;retenu
nge:  mov tab1[di],al
inc di
loop go
call compare
ret
addition endp
;------------------------------------------------
sustraction proc
call compare
sub di,1
push di
call compare2
pop di
cmp inf,1           ; verifie l ordre des operande                                    ;si la premiere superieur on fait une saustraction normal                                    ;si la seconde est superieure on les permutes et on fait
jne  superieur      ; la soustraction
jmp inferieur
inferieur: call compare         ;permet d echanger le contenu
mov cx,cxr           ; de tab1 et tab2
mov di,0             ;
xchge:mov al,tab1[di]      ;
xchg al,tab2[di]     ;
mov tab1[di],al      ;
inc di
loop xchge
mov di,99
cmp tab1[di],0fdh
je positif
mov tab1[di],0fdh
jmp sustraire
positif:  mov tab1[di],0fbh
jmp sustraire
superieur:mov di,99
cmp tab1[di],0fdh
jne positife
mov tab1[di],0fdh
jmp sustraire
positife: mov tab1[di],0fbh
sustraire:  mov di,0
mov cx,cxr
sus: mov al,tab1[di]
cmp al,tab2[di]       ;fait la sustraction entre tab1 et tab2
jae ae
add al,10
add tab2[di+1],1
ae:sub al,tab2[di]
mov tab1[di],al
inc di
loop sus
ret
sustraction endp
;---------------------------------------------------------------------
multiplication proc
mov retenue,0
call find_di
mov dir,di
add dir,2
mov si,98
ver_zero2:  cmp si,0
je find_si
mov al,tab2[si]
cmp al,0
jne find_si
dec si
jmp ver_zero2
find_si: mov sir,si
add sir,2
mov cx,98
mov di,0
range:mov al,tab1[di]     ;range les deux operandes dans les tableaux
mov bl,tab2[di]     ;tab1op et tab2op
mov tab1op[di],al
mov tab2op[di],bl
inc di
loop range
call initialise
mov decalage,0
mov si,0        ;iterations de premiere operande
mult: call initialise2
mov di,0 ;si deuxieme opereande
multip:  mov al,tab2op[si]
mul tab1op[di]
add ax,retenue
mov bl,10   ;extraire
div bl      ;mod et div
;-------------------------------------------------------------------------
push di
add di,decalage     ;decalage
mov tab2[di],ah
pop di
;---------------------------------------------------------
and ax,0000000011111111b  ;extraire al
mov retenue,ax
inc di
cmp di,dir
je fin_mul_1chiffre
jmp multip
;--------------------------------------------------
fin_mul_1chiffre:add decalage,1
call addition     ;additione tab2 avec l ancien resultat
call initialise2  ;resultat dans tab1
inc si
cmp si,sir
je fin_multiplication
mov retenue,0
jmp mult
fin_multiplication:
ret
multiplication endp
;-------------------------------------------------------------------------------------------
;-------------------------------------------------------------------------------------------
division proc
mov si,0
mov di,99
mov al,tab1[di]
mov signe,al
mov cx,99           ;copier tab1 dans tab2div
mov di,98
coo:  mov al,tab1[di]
mov tab2div[di],al
dec di
loop coo
;--------------------------------------------
mov di,99
nnn:cmp tab2div[di],0
jne dirsave           ;on donne di
dec di
jmp nnn
dirsave:mov dir,di
;---------------------------------------------
mov egale,0
call compare2   ;teste si les deux operations sont equivalentes
cmp egale,1
mov axr,-1
je elles_sont_equivalentes
;------------------------------------------
mov al,0
mov axr,-1
mov infzero,1
cmp inf,1       ;teste si la premiere operation est inferieure à la dexieme
je  zeero
mov infzero,0
call initialise
;--------------------------------------
mov di,dir
mov axr,di     ;axr indique la fin de la parite entiere
sub axr,2
;--------------------------------------------------
mov cx,1
mov cxr,cx
rangetab1: mov di,dir
mov cx,cxr
www: mov al,tab2div[di]
and ax,0000000011111111b
push ax
dec di
loop www
mov axr,di
mov bxr,di
mov cx,cxr
mov di,0                 ;extraire les premiers chiffres
tab1ran: pop ax
mov tab1[di],al
inc di
loop tab1ran
push cxr
call compare2
pop cxr
cmp egale,1
je supe
cmp inf,1
jne supe
inc cxr
jmp rangetab1
 
 
;------------------------------------------------
divis:
supe:
call compare2
cmp inf,1
mov al,0       ;teste si la premiere operation est inferieure à la dexieme
je  zeero
push si
call find_di
mov si,98
qaze_si:mov al,tab2[si]
cmp al,0
jne zed_si
dec si
jmp qaze_si
zed_si:
mov al,9
mov bl,tab1[di]
cmp bl,tab2[si]
je sont_egaux
;/---------------------------------------------------
mov al,tab1[di]             ;diviser premir chiffre
cmp al,tab2[si]
jae gg
mov bl,10
mul bl
mov bl,tab1[di-1]
and bx,000000001111111b
add ax,bx
gg: cbw
mov bl,tab2[si]
div bl
and ax,0000000011111111b
sont_egaux: pop si
zeero: mov tabresult[si],al       ;range le resultat de 1 division dans tab1
;----------------------------------------------------------
mov di,0
mov cx,98
nnl:  mov al,tab1[di]      ;deplacer tab1 dans tab1div
mov tab1div[di],al
inc di
loop nnl
;----------------------------------------------------------
push ax
call initialise
pop ax
insatisfait:mov di,0              ;multipie le resultat avec la dexime operande
mov al,tabresult[si]
mov tab1[di],al
push si
 
call multiplication
 
pop si
;--------------------------------------------------------
mov cx,99
mov di,0
tt: mov al,tab1div[di]      ; range dans tab2 le resultat
mov tab2[di],al
inc di
loop tt
;-------------------------------------------------------
call compare2
cmp inf,1               ;teste si le resultat de division est satisfait
je bonn                 ;sinon en decriment le resultat
mov al,tabresult[si]
sub al,1
mov tabresult[si],al
call initialise
;--------------------------------------------------------
mov cx,cxr
mov di,0
tt2:mov al,tab2op[di]      ; range dans tab2 la dexieme operande
mov tab2[di],al
inc di                 ; pour faire la soustraction
loop tt2
jmp insatisfait
;-----------------------------------------------------
bonn: call sustraction
 
;-----------------------------------------------------
call find_di
mov cx,di
inc cx       ;descendre un neauvaux chiffre
mov di,axr  ;contiet le nouveaux chiffre
cmp axr,-1
jnle partie_entiere
mov al,0
inc virdivision
jmp continue_faire
partie_entiere:mov al,tab2div[di]
continue_faire:mov di,0
mov tab1div[di],al
hhh:  mov al,tab1[di]
inc di
mov tab1div[di],al
loop hhh
dec axr       ;teste si la division est terminer
cmp virdivision,8
je finnn
;--------------------------------------------
inc di
yyyy:
mov tab1div[di],0
cmp di,98
je  za
inc di              ;mettre a zero les autres chiffres
jmp yyyy
;-------------------------------------------------
za: mov cx,99
inc cx
mov di,0
ttt2:mov al,tab1div[di]      ; range dans tab1 la 1 operande
mov bl,tab2op[di]
mov tab1[di],al
mov tab2[di],bl
inc di
loop ttt2
inc si
inc result
 
jmp  divis
finnn:dec virdivision
;----------------------------------------------
call initialise
mov di,99
mov al,signe
mov tab1[di],al                                      ;copier tabresult dans tab1
mov cx,98
mov di,0
cccc:   mov al,tabresult[di]
mov tab1[di],al
inc di
loop cccc
call compare
;----------------------------------------------
mov di,result
mov dir,di
mov cx,di
inc cx
push_:mov al,tab1[di]
push ax
dec di
loop push_
mov di,dir
mov cx,di
inc cx
pop_:pop ax
mov tab1[di],al
dec di
loop pop_
;--------------------------------------------
jmp continuer
elles_sont_equivalentes:
call initialise
mov di,0
mov tab1[di],1
jmp normale
continuer: mov ax,virdivision
mov vir,ax
 
normale:ret
division endp
 
ends
end start

02/06/2012, 23h43
bifur

est ce que vous pourriez expliquer textuellement ce qui se passe dans votre programme? (surtout la sous fonction "calcul") j'arrive pas bien a visualiser tout ce qu'il s'y passe.

pour ce qui est de l'incompatibillité de mon programme avec emu8086 ça ne m'étonne pas, il y a toujours des légères différence de syntaxe entre les différent compilateur en plus mon programme est fait pour le format .com qui accepte de mélanger les zones de données alors que vous devez compiler ça en un .exe
03/06/2012, 00h10
goldenprincess

bon pour ce programme j'ai choisis d'utiliser des tableaux pour evaluer les expression arithmetiques jauraidu utiliser les pile mais bon..
au debut je lit la chaine apartir du clavier caractères par caractères et je la mets dans un tableau chaine[] et je fais le traitement pour cahque caractére
la procedure calcule designe "the main" de mon programme elle verifie caratère par caractère si c un nombre ou un opérateur ou bien une virgule
si c le cas on garde son indice de on met dans un autre tableau la partie entier et fractionnaire et on effectue le calcule des autres procédures selon l’opérateur
03/06/2012, 17h09
goldenprincess

il ya aussi un autre problème quand on fait 8-8 il n'affiche pas 0 mais -
comment puisse j régler se problème ?
merci d'avance
04/06/2012, 00h43
bifur

j'ai toujour du mal a comprendre ce qu'il se passe exactement sur votre programme (en plus il est quasiment 3 fois plus long que le mien :scarymov:) ça a l'air tordu comme méthode

par contre j'ai comprit la syntaxe de emu8086 et donc je devrait pouvoir faire une version de mon programme que vous pourrez compiler
04/06/2012, 00h51
goldenprincess

C pas grave merci :)

voila j'ai essayer de passer mon prog en une syntaxe qui devrait être compilable par emu8086 et pour une meilleur compréhension j'y ait rajouter des commentaires

par contre je ne sait pas comment faire pour récuperer la chaine a calculer donc je vous laisse le faire (c'est a inserer en ligne 41)

Code:

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
 
;***************************************************segment de data
donnee    segment 'data'
msgligne:
db 10,13,"$"
msgneg:
db "-$"
sauvesp:
dd 0
msgerreur:
db "erreur$"
ztdeci:
dd 0,0,0,0,0
chaine:
dd 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dd 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
npiconv:
dd 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dd 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
donnee    ends
 
 
 
;**************************************************segment de pile
sseg    segment stack   'stack'
dw      100    dup(?)
sseg    ends
 
 
 
;************************************************segment de code
cseg    segment 'code'
start:
mov ax,donnee
mov ds,ax
mov es,ax
xor dx,dx
mov fs,dx
 
;***************************************************
;inserer ici un code qui place la chaine a décoder en donnee:chaine
;***************************************************
 
mov bx,chaine
mov di,npiconv
mov [sauvesp],esp
 
bcdef:             ;boucle de conversion notation standard > npi
mov al,[bx]
cmp al,"*"
je fois
cmp al,"+"
je plus
cmp al,"/"
je divise 
cmp al,"-"
je moins
cmp al,"0"
je chiffre
cmp al,"1"
je chiffre
cmp al,"2"
je chiffre
cmp al,"3"
je chiffre
cmp al,"4"
je chiffre
cmp al,"5"
je chiffre
cmp al,"6"
je chiffre
cmp al,"7"
je chiffre
cmp al,"8"
je chiffre
cmp al,"9"
je chiffre
cmp al,"."
je point
cmp al,","
je point
cmp al,"("
je paranthese1
cmp al,")"
je paranthese2
jmp fin
 
chiffre:           ;les chiffre sont directement placé sur la chaine de sortie
mov [di],al
inc di
inc bx
jmp bcdef
 
point:            ;point ou virgule on enregistre un point dans la chaine de sortie
mov byte[di],"."  ;(pas utile pour le moment mais il y a bien un jour ou on va
inc di            ;manipuler des nombres décimaux
inc bx
jmp bcdef
 
divise:            ;signe divise, on v‚rifie qu'un multiplication n'est pas en haut de la pile
cmp esp,[sauvesp]
je pilevide
pop dx
cmp dl,"*"
je lkp 
jmp norm
 
plus:           ;signe  - ou + on verifie qu'il n'y a pas une multiplication
moins:          ;ou une division qui soit prioritaire 
cmp esp,[sauvesp]
je pilevide
pop dx
cmp dl,"*"
je lkp 
cmp dl,"/"
je lkp 
 
norm:
push dx           ;rempile ce que l'on vient de dépiler et empile  l'opérande
fois:  
pilevide:
push ax
mov al," "
mov [di],al 
inc di
inc bx
jmp bcdef
 
 
lkp:                 ;place l'opérande que l'on vient de dépiler en sortie
push ax              ;et empile l'opérande dernièrement lu
mov dh," "
mov [di],dh 
inc di
mov [di],dl 
inc di
mov [di],dh 
inc di
inc bx
jmp bcdef
 
 
 
paranthese1:        ;simplement empile la parantèse (
push ax
mov al," "
mov [di],al 
inc di
inc bx
jmp bcdef
 
paranthese2:      ;dépile les opérande et les écrit dans la chaine de sortie
inc bx 
bcdepp2:
cmp esp,[sauvesp]  ;si on atteind la fin de la pile avant d'avoir trouvé une
je erreur          ;paranthèse ( c'est qu'il y a eu une erreur
pop ax
cmp al,"("
je bcdef
mov ah," "
mov [di],ah 
inc di
mov [di],al 
inc di
mov [di],ah 
inc di
jmp bcdepp2
 
erreur:              ;affiche un message d'erreur et fin de prog
mov ah,09h
mov dx,msgerreur
int 21h
mov ax,4C00h
int  21h
 
fin:
cmp esp,[sauvesp]  ;d‚pile tout les op‚rateur restant jusque a la fin de la pile
je okay
pop ax
je bcdef
mov ah," "
mov [di],ah 
inc di
mov [di],al 
inc di
jmp fin
 
okay:
mov byte[di],"$" ;place un symbole $ a la fin de la chaine de sortie
mov ah,09h       ;pour pouvoir ensuite l'afficher
mov dx,npiconv
int 21h
;********************************et maintenant on calcule la chaine codé en npi
mov bx,npiconv   
 
boclcnpi:              ;boucle de calcul en notation npi
mov al,[bx]
cmp al,"*"
je foisnpi
cmp al,"+"
je plusnpi
cmp al,"/"
je divisenpi 
cmp al,"-"
je moinsnpi
cmp al,"0"
je chiffrenpi
cmp al,"1"
je chiffrenpi
cmp al,"2"
je chiffrenpi
cmp al,"3"
je chiffrenpi
cmp al,"4"
je chiffrenpi
cmp al,"5"
je chiffrenpi
cmp al,"6"
je chiffrenpi
cmp al,"7"
je chiffrenpi
cmp al,"8"
je chiffrenpi
cmp al,"9"
je chiffrenpi
cmp al,"$"
je finpi
inc bx
jmp boclcnpi
 
foisn:                         ;dépile les deux dernier nombres
pop ecx
pop eax
xor edx,edx
imul ecx                      ;les multiplie (signé)
push eax                      ;rempile le résultat
inc bx
jmp boclcnpi
 
divisenpi:                  ;dépile les deux dernier nombres
pop ecx
pop eax
xor edx,edx
idiv ecx                      ;effectue la division (signé)
push eax                     ;rempile le résultat
inc bx
jmp boclcnpi
 
moinsnpi:                ;dépile les deux dernier nombres
pop ecx
pop eax
sub eax,ecx
push eax                 ;rempile le résultat
inc bx
jmp boclcnpi
 
plusnpi:                ;dépile les deux dernier nombres
pop ecx
pop eax
add eax,ecx
push eax                 ;rempile le résultat
inc bx
jmp boclcnpi
 
chiffrenpi:         ;on décode le nomre et on l'empile
xor edx,edx
bochifnpi:
mov al,[bx]
cmp al," "
je findecod     ;sion tombe sur un espace c'est qu'on a finit de lire le nombre
sub al,"0"
and eax,0Fh
mov ecx,edx         ;divise edx par dix  1) on dédouble la variable
shl edx,3           ;2) on multiplie l'un par 8 (décalage de 3 bit)
shl ecx,1           ;3) on multiplie l'autre par 2 (décalage de 1 bit)
add edx,ecx         ;4) on additionne les résultat
add edx,eax
inc bx
jmp bochifnpi
 
findecod:
push edx
inc bx
jmp boclcnpi
 
 
finpi:
mov ah,09h
mov dx,msgligne
int 21h
 
 
pop eax
test eax,80000000h
jz pasneg
push eax
mov ah,09h
mov dx,msgneg
int 21h
pop eax
neg eax
pasneg:
call deci32              ;on affiche le nombre
 
mov ax,4C00h             ;fin
int  21h
 
 
deci32:                  ;sous fonction qui affiche le nombre contenu dans eax
push eax                 ;en non signé
push ecx
push edx
push si
 
mov si,ztdeci+11
mov cl,"$"
mov [si],cl
mov ecx,10
 
bd32:
xor edx,edx
div ecx
add dl,48
dec si
mov [si],dl
cmp si,ztdeci
jne bd32
 
dec si
ajust:
inc si
mov al,[si]
cmp al,"0"
je ajust
cmp al,"$"
jne nzer
dec si
nzer:
mov dx,si
mov ah,09h
int 21h
 
pop si
pop edx
pop ecx
pop eax
ret
 
cseg    ends

merci de bien vouloir me faire savoir si ça marche et de quel manière vous récuperez la chaine a calculer