API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 14th, 2019
91
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Z80 Assembler 16.66 KB | None | 0 0
raw download clone embed print report
  1. include console.inc
  2. .STACK 4096
  3. .DATA  
  4.         MISTAKE DB 'SOME KIND OF MISTAKE MAAAN',0
  5.         prov DB 'JUST PROVERKA MAN',0
  6.         MISK DB 'RAZNIE RAZMERI OPERANDOV',0
  7.         B1 db ?
  8.         B2 db ?
  9.         B3 db ?
  10.         W1 dw ?
  11.         W2 dw ?
  12.         W3 dw ?
  13.         D1 dd ?
  14.         D2 dd ?
  15.         D3 dd ?
  16.         Q1 dq ?
  17.         Q2 dq ?
  18.         Q3 dq ?
  19.         ADDTHREE MACRO A,B,C
  20.         LOCAL Z1
  21.         PUSH ESP
  22.         PUSH EAX
  23.         ;IF '&A&' EQ
  24.         IFIDNI <A>,<AX>
  25.                 ELSE
  26.                 IFIDNI <B>,<AX>
  27.                     ELSE
  28.                     IFIDNI <C>,<AX>
  29.                     ELSE ;AX - FREE REGISTER
  30.                     OUTCH 'A'
  31.                     NEWLINE
  32.                     MOV AX,B
  33.                     ADD A,AX
  34.                     MOV AX,C
  35.                     ADD A,AX
  36.                     JMP Z1
  37.                     ENDIF
  38.                 ENDIF
  39.         ENDIF
  40.        
  41.                 IFIDNI <A>,<BX>
  42.                 ELSE
  43.                     IFIDNI <B>,<BX>
  44.                         ELSE
  45.                         IFIDNI <C>,<BX>
  46.                         ELSE ;BX - FREE REGISTER
  47.                         OUTCH 'B'
  48.                         NEWLINE
  49.                         MOV BX,B
  50.                         ADD A,BX
  51.                         MOV BX,C
  52.                         ADD A,BX
  53.                         JMP Z1
  54.                         ENDIF
  55.                     ENDIF
  56.         ENDIF
  57.                 IFIDNI <A>,<CX>
  58.                 ELSE
  59.                 IFIDNI <B>,<CX>
  60.                     ELSE
  61.                     IFIDNI <C>,<CX>
  62.                     ELSE ;AX - FREE REGISTER
  63.                     OUTCH 'C'
  64.                     NEWLINE
  65.                     MOV CX,B
  66.                     ADD A,CX
  67.                     MOV CX,C
  68.                     ADD A,CX
  69.                     JMP Z1
  70.                     ENDIF
  71.                 ENDIF
  72.         ENDIF
  73.                 IFIDNI <A>,<DX>
  74.                 ELSE
  75.                 IFIDNI <B>,<DX>
  76.                     ELSE
  77.                     IFIDNI <C>,<DX>
  78.                     ELSE ;AX - FREE REGISTER
  79.                     OUTCH 'D'
  80.                     NEWLINE
  81.                     MOV DX,B
  82.                     ADD A,DX
  83.                     MOV DX,C
  84.                     ADD A,DX
  85.                     JMP Z1
  86.                     ENDIF
  87.                 ENDIF
  88.         ENDIF
  89.        
  90.         IF (TYPE A NE TYPE B) OR (TYPE A NE TYPE C) OR (TYPE B NE TYPE C)
  91.             OUTSTR OFFSET MISK
  92.             NEWLINE
  93.         ENDIF
  94.         IF TYPE A LE 4 AND TYPE A GE 1; помещаем в стек переменные
  95.  
  96.                 PUSH 1 ;, если они размером от byte до dword
  97.                 IF TYPE A EQ BYTE
  98.                         MOV AH, A
  99.                         MOV BYTE PTR [ESP],AH
  100.                         MOV BYTE PTR [ESP+1],0 ;очищаем "мусор"
  101.                         MOV BYTE PTR [ESP+2],0
  102.                         MOV BYTE PTR [ESP+3],0
  103.                         MOV EAX, [ESP+4]
  104.                 ENDIF
  105.                 IF TYPE A EQ WORD
  106.                         IFIDN <SP>,<A>
  107.                                 MOV AX, WORD PTR [ESP+8]
  108.                                 MOV WORD PTR [ESP],AX
  109.                                 MOV BYTE PTR [ESP+2],0
  110.                                 MOV BYTE PTR [ESP+3],0
  111.                                 MOV EAX, [ESP+4]
  112.                         ELSE
  113.                                 MOV AX,A
  114.                                 MOV WORD PTR [ESP],AX
  115.                                 MOV BYTE PTR [ESP+2],0
  116.                                 MOV BYTE PTR [ESP+3],0
  117.                                 MOV EAX,[ESP+4]
  118.                         ENDIF
  119.                                
  120.                 ENDIF
  121.                 IF TYPE A EQ DWORD
  122.                         IFIDN <ESP>,<A> ; ЕСЛИ А = ESP КАК ЭЛЕМЕНТ
  123.                                 MOV EAX,[ESP+8]
  124.                                 MOV DWORD PTR [ESP],EAX
  125.                                 MOV EAX, [ESP+4]
  126.                         ELSE
  127.                                 MOV EAX,A
  128.                                 MOV DWORD PTR [ESP],EAX
  129.                                 MOV EAX,[ESP+4]
  130.                         ENDIF
  131.                 ENDIF
  132.                
  133.  
  134.         ELSEIF TYPE A EQ 0
  135.                 PUSH A
  136.         ENDIF
  137.         outu [ESP]
  138.         newline
  139.        
  140.        
  141.        
  142.        
  143.        
  144.        
  145.        
  146.         IF TYPE B LE 4 AND TYPE B GE 1; помещаем в стек переменные
  147.                 PUSH 1 ;, если они размером от byte до dword
  148.                 IF TYPE B EQ BYTE
  149.                         MOV AH,B
  150.                         MOV BYTE PTR [ESP],AH
  151.                         MOV BYTE PTR [ESP+1],0 ;очищаем "мусор"
  152.                         MOV BYTE PTR [ESP+2],0
  153.                         MOV BYTE PTR [ESP+3],0
  154.                         MOV EAX,[ESP+8]
  155.                 ENDIF
  156.                 IF TYPE B EQ WORD
  157.                         IFIDN <SP>,<B>
  158.                                 outstr offset prov
  159.                                 newline
  160.                                 MOV AX, WORD PTR [ESP+12]
  161.                                 MOV WORD PTR [ESP],AX
  162.                                 MOV BYTE PTR [ESP+2],0
  163.                                 MOV BYTE PTR [ESP+3],0
  164.                                 MOV EAX, [ESP+8]
  165.                         ELSE
  166.                                 MOV AX,B
  167.                                 MOV WORD PTR [ESP],AX
  168.                                 MOV BYTE PTR [ESP+2],0
  169.                                 MOV BYTE PTR [ESP+3],0
  170.                                 MOV EAX,[ESP+8]
  171.                         ENDIF
  172.                                
  173.                 ENDIF
  174.                 IF TYPE B EQ DWORD
  175.                         IFIDN <ESP>,<B> ; ЕСЛИ А = ESP КАК ЭЛЕМЕНТ
  176.                                 MOV EAX,[ESP+12]
  177.                                 MOV DWORD PTR [ESP],EAX
  178.                                 MOV EAX, [ESP+8]
  179.                         ELSE
  180.                                 MOV EAX,A
  181.                                 MOV DWORD PTR [ESP],EAX
  182.                                 MOV EAX,[ESP+8]
  183.                         ENDIF
  184.                 ENDIF
  185.  
  186.  
  187.         ELSEIF TYPE B EQ 0
  188.                 PUSH B
  189.        
  190.         ENDIF
  191.         outu [ESP]
  192.         newline
  193.         IF TYPE C LE 4 AND TYPE C GE 1; помещаем в стек переменные
  194.                 PUSH 1 ;, если они размером от byte до dword
  195.                 IF TYPE C EQ BYTE
  196.                         MOV AH,C
  197.                         MOV BYTE PTR [ESP],AH
  198.                         MOV BYTE PTR [ESP+1],0 ;очищаем "мусор"
  199.                         MOV BYTE PTR [ESP+2],0
  200.                         MOV BYTE PTR [ESP+3],0
  201.                         MOV EAX,[ESP+12]
  202.                 ENDIF
  203.                 IF TYPE C EQ WORD
  204.                         IFIDN <SP>,<C>
  205.                                 outstr offset prov
  206.                                 newline
  207.                                 MOV AX, WORD PTR [ESP+16]
  208.                                 MOV WORD PTR [ESP],AX
  209.                                 MOV BYTE PTR [ESP+2],0
  210.                                 MOV BYTE PTR [ESP+3],0
  211.                                 MOV EAX, [ESP+12]
  212.                         ELSE
  213.                                 MOV AX,C
  214.                                 MOV WORD PTR [ESP],AX
  215.                                 MOV BYTE PTR [ESP+2],0
  216.                                 MOV BYTE PTR [ESP+3],0
  217.                                 MOV EAX,[ESP+12]
  218.                         ENDIF
  219.                                
  220.                 ENDIF
  221.                 IF TYPE C EQ DWORD
  222.                         IFIDN <ESP>,<C> ; ЕСЛИ А = ESP КАК ЭЛЕМЕНТ
  223.                                 MOV EAX,[ESP+16]
  224.                                 MOV DWORD PTR [ESP],EAX
  225.                                 MOV EAX, [ESP+12]
  226.                         ELSE
  227.                                 MOV EAX,C
  228.                                 MOV DWORD PTR [ESP],EAX
  229.                                 MOV EAX,[ESP+12]
  230.                         ENDIF
  231.                 ENDIF
  232.  
  233.  
  234.         ELSEIF TYPE C EQ 0
  235.                 PUSH C
  236.         ELSEIF TYPE C EQ 8
  237.                 PUSH DWORD PTR C
  238.                 PUSH DWORD PTR C+4
  239.         ENDIF
  240.         outu [ESP]
  241.         newline
  242.         MOV EAX,0; обнуляем наш арифмитический регистр
  243.        
  244.         IF TYPE A EQ 0
  245.                 IF TYPE B EQ 0;1-START
  246.                                 IF TYPE C EQ 0;2-START
  247.                                         OUTSTR OFFSET MISTAKE
  248.                                        
  249.                                 ELSEIF TYPE C EQ 1
  250.                                 MOV AH, BYTE PTR [ESP+4]
  251.                                 ADD BYTE PTR [ESP], AH
  252.                                 MOV AH, BYTE PTR [ESP+8]
  253.                                 ADD BYTE PTR [ESP], AH
  254.                                 MOV AH, BYTE PTR [ESP]
  255.                                 MOV C, AH
  256.                                
  257.                                 ELSEIF TYPE C EQ 2
  258.                                 MOV AX, WORD PTR [ESP+4]
  259.                                 ADD WORD PTR [ESP], AX
  260.                                 MOV AX, WORD PTR [ESP+8]
  261.                                 ADD WORD PTR [ESP], AX
  262.                                 MOV AX, WORD PTR [ESP]
  263.                                 MOV C, AX
  264.                                
  265.                                 ELSEIF TYPE C EQ 4
  266.                                 MOV EAX, [ESP+4]
  267.                                 ADD [ESP], EAX
  268.                                 MOV EAX, [ESP+8]
  269.                                 ADD [ESP], EAX
  270.                                 MOV EAX, [ESP]
  271.                                 MOV C, EAX
  272.                                
  273.                                ELSE
  274.                                MOV EAX,[ESP+4]
  275.                                ADD DWORD PTR C,EAX
  276.                                ADC DWORD PTR C+4,0
  277.                                MOV EAX, [ESP+8]
  278.                                ADD DWORD PTR C,EAX
  279.                                ADC DWORD PTR C+4,0
  280.                                
  281.                                ENDIF;2-END
  282.                  
  283.                  ELSEIF TYPE C GT TYPE B
  284.                                 OUTSTR OFFSET MISTAKE;Если b - ненулевой
  285.                  ELSEIF TYPE B EQ BYTE
  286.                                        MOV AH, byte ptr [ESP]
  287.                                        ADD byte ptr [ESP+4], AH
  288.                                        MOV AH, BYTE PTR [ESP+8]
  289.                                        ADD BYTE PTR [ESP+4], AH
  290.                                        MOV AH, BYTE PTR [ESP+4]
  291.                                        MOV B,AH
  292.                   ELSEIF TYPE B EQ WORD
  293.                                        MOV AX, WORD ptr [ESP]
  294.                                        ADD WORD ptr [ESP+4], AX
  295.                                        MOV AX, WORD PTR [ESP+8]
  296.                                        ADD WORD PTR [ESP+4], AX
  297.                                        MOV AX, WORD PTR [ESP+4]
  298.                                        MOV B,AX
  299.                   ELSEIF TYPE B EQ DWORD
  300.                                        MOV EAX, [ESP]
  301.                                        ADD [ESP+4], EAX
  302.                                        MOV EAX, [ESP+8]
  303.                                        ADD [ESP+4], EAX
  304.                                        MOV EAX, [ESP+4]
  305.                                        MOV B,EAX
  306.                   ELSEIF TYPE B EQ QWORD
  307.                         IF TYPE C EQ QWORD
  308.                                 MOV EAX,[ESP+8]
  309.                                 ADD DWORD PTR B,EAX
  310.                                 ADC DWORD PTR B+4,0
  311.                                 MOV EAX,DWORD PTR C
  312.                                 ADD DWORD PTR B,EAX
  313.                                 ADC DWORD PTR B+4,0
  314.                                 MOV EAX,DWORD PTR C+4
  315.                                 ADD DWORD PTR B,EAX
  316.                         ELSE
  317.                                 MOV EAX,[ESP+8]
  318.                                 ADD DWORD PTR B,EAX
  319.                                 ADC DWORD PTR B+4,0
  320.                                 MOV EAX,[ESP]
  321.                                 ADD DWORD PTR B,EAX
  322.                                 ADC DWORD PTR B+4,0
  323.                         ENDIF
  324.                   ENDIF        
  325.                
  326.  
  327.        
  328.         ELSEIF TYPE A EQ BYTE; случай, когда первый операнд - byte
  329.                IF TYPE B LE 1 AND TYPE C LE 1
  330.                        MOV AH, byte ptr [ESP]
  331.                        ADD byte ptr [ESP+8], AH
  332.                        MOV AH, BYTE PTR [ESP+4]
  333.                        ADD BYTE PTR [ESP+8], AH
  334.                        MOV AH, BYTE PTR [ESP+8]
  335.                        MOV A,AH
  336.                ELSE
  337.                        OUTSTR OFFSET MISTAKE
  338.                ENDIF
  339.        
  340.        
  341.  
  342.  
  343.         ELSEIF TYPE A EQ WORD
  344.  
  345.         IF TYPE B LE 2 AND TYPE C LE 2
  346.                        MOV AX, WORD ptr [ESP]
  347.                        ADD WORD ptr [ESP+8], AX
  348.                        MOV AX, WORD PTR [ESP+4]
  349.                        ADD WORD PTR [ESP+8], AX
  350.                        MOV AX, WORD PTR [ESP+8]
  351.                        MOV A,AX
  352.                        
  353.                ELSE
  354.                        OUTSTR OFFSET MISTAKE
  355.                ENDIF
  356.  
  357.         ELSEIF TYPE A EQ DWORD
  358.        
  359.         IF TYPE B LE 4 AND TYPE C LE 4
  360.                        MOV EAX,[ESP]
  361.                        ADD [ESP+8], EAX
  362.                        MOV EAX, [ESP+4]
  363.                        ADD [ESP+8], EAX
  364.                        MOV EAX,[ESP+8]
  365.                        MOV A,EAX
  366.                ELSE
  367.                        OUTSTR OFFSET MISTAKE
  368.                ENDIF
  369.         ELSEIF TYPE A EQ QWORD
  370.                 IF (TYPE B EQ 8) AND (TYPE C EQ 8) ; Type b = type c = q
  371.                         IFIDN <A>,<C>
  372.                                 PUSH DWORD PTR C
  373.                                 PUSH DWORD PTR C+4
  374.                                 MOV EAX, DWORD PTR B
  375.                                 ADD DWORD PTR A,EAX
  376.                                 ADC DWORD PTR A+4,0
  377.                                 MOV EAX, DWORD PTR B+4
  378.                                 ADD DWORD PTR A+4, EAX
  379.                                 MOV EAX, [ESP+4]
  380.                                 ADD DWORD PTR A,EAX
  381.                                 ADC DWORD PTR A+4,0
  382.                                 MOV EAX,[ESP]
  383.                                 ADD DWORD PTR A+4,EAX
  384.                                
  385.                        
  386.                         ELSE
  387.                                 MOV EAX,DWORD PTR B
  388.                                 ADD DWORD PTR A,EAX
  389.                                 ADC DWORD PTR A+4, 0
  390.                                 MOV EAX,DWORD PTR B+4
  391.                                 ADD DWORD PTR A+4,EAX
  392.                                 MOV EAX,DWORD PTR C
  393.                                 ADD DWORD PTR A,EAX
  394.                                 ADC DWORD PTR A+4,0
  395.                                 MOV EAX,DWORD PTR C+4
  396.                                 ADD DWORD PTR A+4,EAX
  397.                         ENDIF
  398.                
  399.                
  400.                 ELSEIF TYPE B NE 8 AND TYPE C EQ 8 ; type b !=q type c = q
  401.                 MOV EAX,DWORD PTR [ESP+4]
  402.                 ADD DWORD PTR A,EAX
  403.                 ADC DWORD PTR A+4,0
  404.                 MOV EAX,DWORD PTR C
  405.                 ADD DWORD PTR A,EAX
  406.                 ADC DWORD PTR A+4,0
  407.                 MOV EAX,DWORD PTR C+4
  408.                 ADD DWORD PTR A+4,EAX
  409.                
  410.                
  411.                
  412.                
  413.                 ELSEIF TYPE B EQ 8 AND TYPE C NE 8 ; type b = q type c !=q
  414.                 MOV EAX,DWORD PTR [ESP]
  415.                 ADD DWORD PTR A,EAX
  416.                 ADC DWORD PTR A+4,0
  417.                 MOV EAX,DWORD PTR B
  418.                 ADD DWORD PTR A,EAX
  419.                 ADC DWORD PTR A+4,0
  420.                 MOV EAX,DWORD PTR B+4
  421.                 ADD DWORD PTR A+4,EAX
  422.                
  423.                 ELSEIF TYPE B NE 8 AND TYPE C NE 8 ; Type b !=q type c != q
  424.                 MOV EAX,DWORD PTR [ESP]
  425.                 ADD DWORD PTR A,EAX
  426.                 ADC DWORD PTR A+4,0
  427.                 MOV EAX,DWORD PTR [ESP+4]
  428.                 ADD DWORD PTR A,EAX
  429.                 ADC DWORD PTR A+4,0
  430.                 ENDIF
  431.        
  432.        
  433.         ENDIF
  434.        
  435.        
  436.         Z1:
  437.         OUTU A
  438.         newline
  439.         OUTU B
  440.         newline
  441.         OUTU C
  442.         newline
  443.         ENDM
  444.        
  445.         .CODE
  446.         START:
  447.         ;байты
  448.         MOV byte ptr B1,5
  449.         MOV byte ptr B2,6
  450.         MOV byte ptr B3,7
  451.         ;слова
  452.         MOV word ptr W1,5
  453.         MOV word ptr W2,6
  454.         MOV word ptr W3,7
  455.         ;dword
  456.         MOV dword ptr D1,5
  457.         MOV dword ptr D2,6
  458.         MOV dword ptr D3,7
  459.         ;qword
  460.         MOV dword ptr Q1,4
  461.         MOV dword ptr Q2,4
  462.         MOV dword ptr Q3,4
  463.        
  464.         MOV dword ptr Q1+4,0
  465.         MOV dword ptr Q2+4,0
  466.         MOV dword ptr Q3+4,0
  467.         ;ADDTHREE B1,B2,B3
  468.         ;ADDTHREE B2,B3,B1
  469.         ;ADDTHREE W1,W2,W3
  470.         ;ADDTHREE W3,W2,W1
  471.         ;ADDTHREE D1,D2,D3
  472.         ;ADDTHREE W1,B1,W3
  473.         ;ADDTHREE D2,W2,B2
  474.         ;ADDTHREE B3,B1,W2
  475.         ;ADDTHREE B1,B2,7
  476.         ;ADDTHREE W1,5,20
  477.         ;ADDTHREE 5,B1,4
  478.         ;ADDTHREE D2,5,6
  479.         ;ADDTHREE 5,2,W3
  480.         MOV AX,10
  481.         MOV BX,20
  482.         MOV DX,30
  483.         ADDTHREE AX,bx,Dx
  484.         ;ADDTHREE AX,W1,W2
  485.         ;ADDTHREE W1,W2,SI
  486.         ;ADDTHREE AL,B2,CL
  487.         ;ADDTHREE AX,W2,DL
  488.         ;ADDTHREE AX,B3,BL
  489.        
  490.        
  491.        
  492. exit
  493. END START
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!