home *** CD-ROM | disk | FTP | other *** search
/ The Education Master 1994 (4th Edition) / EDUCATIONS_MASTER_4TH_EDITION.bin / files / progscal / tinypasc / turun.asm < prev    next >
Encoding:
Assembly Source File  |  1986-02-24  |  9.6 KB  |  363 lines
  1.  ; Tiny Pascal assembler code
  2.           MOV   SP,OFFSET(STACKORG)
  3.           MOV   BP,SP
  4.           CALL  MAIN
  5.           INT   020H
  6.  ; <STDIO.HDR> included
  7. ;  STDIO.HDR
  8. ;
  9. ;  READ and WRITE routines needed for Tiny Pascal
  10. ;
  11. SYS_RCHAR   PROC   NEAR   ; Read single character from stdin
  12.             MOV    AH,1
  13.             INT    021H
  14.             RET           ; value comes back in AL
  15.             ENDP
  16.  
  17. SYS_WRCHAR  PROC   NEAR   ; Write a single character (in DL) to stdin
  18.             MOV    AH,2
  19.             INT    021H
  20.             RET
  21.             ENDP
  22.  
  23. SYS_WHEX    PROC   NEAR   ; Write a single HEX number (in DL) to stdin
  24.             CMP    DL,10
  25.             JL     SYS_01
  26.             ADD    DL,55     ; 'A' - 10
  27.             CALL   SYS_WRCHAR
  28.             RET
  29. SYS_01      ADD    DL,'0'
  30.             CALL   SYS_WRCHAR
  31.             RET
  32.             ENDP
  33.  
  34. SYS_IWRT    PROC   NEAR   ; Write an integer to stdout in HEX
  35.             MOV    DH,4   ; used as a counter
  36. SYS_11      ROL    AX
  37.             ROL    AX
  38.             ROL    AX
  39.             ROL    AX
  40.             MOV    DL,AL
  41.             AND    DL,0FH
  42.             PUSH   AX
  43.             CALL   SYS_WHEX
  44.             POP    AX
  45.             DEC    DH
  46.             JNZ    SYS_11
  47.             RET
  48.             ENDP
  49.  
  50. SYS_SWRT    PROC   NEAR   ; Write a string terminated by 0 to stdout
  51. SYS_21      MOV    DL,0[BX]
  52.             CMP    DL,0
  53.             JNZ    SYS_22   ; zero terminator?
  54.             RET
  55. SYS_22      CALL   SYS_WRCHAR
  56.             INC    BX
  57.             JMPS   SYS_21
  58.             ENDP
  59.  
  60. SYS_WRTLN   PROC   NEAR    ; write carriage return/line feed to stdout
  61.             MOV    DL,0DH
  62.             CALL   SYS_WRCHAR
  63.             MOV    DL,0AH
  64.             CALL   SYS_WRCHAR
  65.             RET
  66.             ENDP
  67.  
  68. READ        PROC   NEAR         ; read a HEX number from STDIN
  69.             MOV    DX,0         ; clear DX
  70. READ_01     CALL   SYS_RCHAR    ; get one character in AL
  71.                     ; won't affect DX
  72.             CMP    AL,0DH
  73.             JNZ    READ_02
  74.             PUSH   DX           ; save the thing we've done
  75.             CALL   SYS_WRTLN    ; send a carriage return/line feed
  76.             POP    AX           ; was an ENTER
  77.             RET
  78. READ_02     CMP    AL,' '
  79.             JZ     READ_01      ; ignore spaces
  80.             SUB    AL,'0'       ; start conversion to binary
  81.             CMP    AL,9
  82.             JLE    READ_03
  83.             SUB    AL,7         ; turn 'A' into 0AH
  84. READ_03     CMP    AL,0FH
  85.             JLE    READ_04
  86.             SUB    AL,32        ; turn 'a' into 0AH
  87. READ_04     AND    AL,0FH       ; clip for good measure
  88.             SHL    DX           ; prepare DX for hex value
  89.             SHL    DX
  90.             SHL    DX
  91.             SHL    DX
  92.             OR     DL,AL
  93.             JMPS   READ_01      ; go do some more
  94.             ENDP
  95.  
  96. READLN      PROC   NEAR
  97.             JMPS   READ         ; does the same thing
  98.             ENDP
  99.  
  100.  ; ... end of include STDIO.HDR
  101.  ;   {TURUN -- A sample program written in Tiny Pascal }
  102.  ;   var I, J, K, PROBLEM;
  103.  ;   
  104.  ;   {*********************}
  105.  ;   function ISLESS(N1, N2);
  106.  ;   begin  {returns 1 if n1<n2, 0 otherwise}
  107.  ;     if n2-n1 then isless:=1   {truth value test is >0}
  108.  ;     else isless:=0;
  109.  ;     end;
  110. ISLESS    PROC  NEAR
  111.           PUSH  BP
  112.           MOV   BP,SP
  113.           MOV   AX,4[BP] ; N2
  114.           SUB   AX,6[BP] ; N1
  115.           CMP   AX,0
  116.           JLE   XXX0
  117.           MOVW  8[BP],1 ; ISLESS
  118.           JMP   XXX1
  119. XXX0      EQU   $
  120.           MOVW  8[BP],0 ; ISLESS
  121. XXX1      EQU   $
  122.           MOV   AX,8[BP] ; ISLESS
  123.           POP   BP
  124.           RET   6
  125.           ENDP
  126.  ;    SYMBOL TABLE
  127.  ; ISLESS                          8[BP]
  128.  ; N1                              6[BP]
  129.  ; N2                              4[BP]
  130.  
  131.  ;     
  132.  ;   function ADDEMUP(LOWER, UPPER, SUM);
  133.  ;   begin end;    {makes it a forward declaration}
  134.  ;   
  135.  ;   {*********************}
  136.  ;   function ISEQUAL(N1, N2);
  137.  ;   begin
  138.  ;     if n2-n1 then isequal:=0   {false}
  139.  ;     else
  140.  ;     if n1-n2 then isequal:=0
  141.  ;     else isequal:=1;
  142.  ;     end;
  143. ISEQUAL   PROC  NEAR
  144.           PUSH  BP
  145.           MOV   BP,SP
  146.           MOV   AX,4[BP] ; N2
  147.           SUB   AX,6[BP] ; N1
  148.           CMP   AX,0
  149.           JLE   XXX2
  150.           MOVW  8[BP],0 ; ISEQUAL
  151.           JMP   XXX3
  152. XXX2      EQU   $
  153.           MOV   AX,6[BP] ; N1
  154.           SUB   AX,4[BP] ; N2
  155.           CMP   AX,0
  156.           JLE   XXX4
  157.           MOVW  8[BP],0 ; ISEQUAL
  158.           JMP   XXX5
  159. XXX4      EQU   $
  160.           MOVW  8[BP],1 ; ISEQUAL
  161. XXX5      EQU   $
  162. XXX3      EQU   $
  163.           MOV   AX,8[BP] ; ISEQUAL
  164.           POP   BP
  165.           RET   6
  166.           ENDP
  167.  ;    SYMBOL TABLE
  168.  ; ISEQUAL                         8[BP]
  169.  ; N1                              6[BP]
  170.  ; N2                              4[BP]
  171.  
  172.  ;     
  173.  ;   {***********************}
  174.  ;   function ADDEMUP(LOWER, UPPER, SUM);
  175.  ;         {SUM is a local}
  176.  ;   begin
  177.  ;     sum:=0;
  178.  ;     while isless(lower, upper) do begin
  179.  ;       sum:=sum+lower;
  180.  ;       lower:=lower+1;
  181.  ;       end;
  182.  ;     addemup:=sum+lower;  { the last one was left out }
  183.  ;     end;
  184. ADDEMUP   PROC  NEAR
  185.           PUSH  BP
  186.           MOV   BP,SP
  187.           MOVW  4[BP],0 ; SUM
  188. XXX6      EQU   $
  189.           PUSH  AX
  190.           MOV   AX,8[BP] ; LOWER
  191.           PUSH  AX
  192.           MOV   AX,6[BP] ; UPPER
  193.           PUSH  AX
  194.           CALL  ISLESS
  195.           CMP   AX,0
  196.           JLE   XXX7
  197.           MOV   AX,4[BP] ; SUM
  198.           ADD   AX,8[BP] ; LOWER
  199.           MOV   4[BP],AX ; SUM
  200.           MOV   AX,8[BP] ; LOWER
  201.           ADD   AX,1
  202.           MOV   8[BP],AX ; LOWER
  203.           JMP   XXX6
  204. XXX7      EQU   $
  205.           MOV   AX,4[BP] ; SUM
  206.           ADD   AX,8[BP] ; LOWER
  207.           MOV   10[BP],AX ; ADDEMUP
  208.           MOV   AX,10[BP] ; ADDEMUP
  209.           POP   BP
  210.           RET   8
  211.           ENDP
  212.  ;    SYMBOL TABLE
  213.  ; ADDEMUP                         10[BP]
  214.  ; LOWER                           8[BP]
  215.  ; UPPER                           6[BP]
  216.  ; SUM                             4[BP]
  217.  
  218.  ; 
  219.  ;   {*********************}
  220.  ;   function MAIN(SUM, UPPER);
  221.  ;   begin
  222.  ;     i:=1;
  223.  ;     j:=i+5;
  224.  ;     k:=j-16;
  225.  ;     problem:=i+(j*k);
  226.  ;     writeln('I: ', i, ' J: ', j, ' K: ', k, ' Problem: ', problem);
  227.  ;     write('Enter upper ');
  228.  ;     upper:=read;
  229.  ;     sum:=addemup(1, upper);  {sum of integers 1..upper}
  230.  ;     if isequal(sum, (upper*(upper+1))/2) then
  231.  ;       writeln('Sum = ', sum)
  232.  ;     else begin
  233.  ;       writeln('BUG: Sum = ', sum, '; should be ',
  234.  ;                  (upper*(upper+1))/2);
  235.  ;       end;
  236.  ;     end;
  237. MAIN      PROC  NEAR
  238.           PUSH  BP
  239.           MOV   BP,SP
  240.           MOVW  I,1 ; I
  241.           MOV   AX,I ; I
  242.           ADD   AX,5
  243.           MOV   J,AX ; J
  244.           MOV   AX,J ; J
  245.           SUB   AX,16
  246.           MOV   K,AX ; K
  247.           MOV   AX,K ; K
  248.           PUSH  AX
  249.           MOV   AX,J ; J
  250.           POP   CX
  251.           IMULW CX
  252.           PUSH  AX
  253.           MOV   AX,I ; I
  254.           POP   DX
  255.           ADD   AX,DX
  256.           MOV   PROBLEM,AX ; PROBLEM
  257.           MOV   BX,OFFSET(SS0)
  258.           CALL  SYS_SWRT
  259.           MOV   AX,I ; I
  260.           CALL  SYS_IWRT
  261.           MOV   BX,OFFSET(SS1)
  262.           CALL  SYS_SWRT
  263.           MOV   AX,J ; J
  264.           CALL  SYS_IWRT
  265.           MOV   BX,OFFSET(SS2)
  266.           CALL  SYS_SWRT
  267.           MOV   AX,K ; K
  268.           CALL  SYS_IWRT
  269.           MOV   BX,OFFSET(SS3)
  270.           CALL  SYS_SWRT
  271.           MOV   AX,PROBLEM ; PROBLEM
  272.           CALL  SYS_IWRT
  273.           CALL  SYS_WRTLN
  274.           MOV   BX,OFFSET(SS4)
  275.           CALL  SYS_SWRT
  276.           CALL  READ
  277.           MOV   4[BP],AX ; UPPER
  278.           PUSH  AX
  279.           MOV   AX,1
  280.           PUSH  AX
  281.           MOV   AX,4[BP] ; UPPER
  282.           PUSH  AX
  283.           MOV   AX,0
  284.           PUSH  AX
  285.           CALL  ADDEMUP
  286.           MOV   6[BP],AX ; SUM
  287.           PUSH  AX
  288.           MOV   AX,6[BP] ; SUM
  289.           PUSH  AX
  290.           MOV   AX,2
  291.           PUSH  AX
  292.           MOV   AX,4[BP] ; UPPER
  293.           ADD   AX,1
  294.           PUSH  AX
  295.           MOV   AX,4[BP] ; UPPER
  296.           POP   CX
  297.           IMULW CX
  298.           CWD
  299.           POP   CX
  300.           IDIVW CX
  301.           PUSH  AX
  302.           CALL  ISEQUAL
  303.           CMP   AX,0
  304.           JLE   XXX8
  305.           MOV   BX,OFFSET(SS5)
  306.           CALL  SYS_SWRT
  307.           MOV   AX,6[BP] ; SUM
  308.           CALL  SYS_IWRT
  309.           CALL  SYS_WRTLN
  310.           JMP   XXX9
  311. XXX8      EQU   $
  312.           MOV   BX,OFFSET(SS6)
  313.           CALL  SYS_SWRT
  314.           MOV   AX,6[BP] ; SUM
  315.           CALL  SYS_IWRT
  316.           MOV   BX,OFFSET(SS7)
  317.           CALL  SYS_SWRT
  318.           MOV   AX,2
  319.           PUSH  AX
  320.           MOV   AX,4[BP] ; UPPER
  321.           ADD   AX,1
  322.           PUSH  AX
  323.           MOV   AX,4[BP] ; UPPER
  324.           POP   CX
  325.           IMULW CX
  326.           CWD
  327.           POP   CX
  328.           IDIVW CX
  329.           CALL  SYS_IWRT
  330.           CALL  SYS_WRTLN
  331. XXX9      EQU   $
  332.           MOV   AX,8[BP] ; MAIN
  333.           POP   BP
  334.           RET   6
  335. SS7       DB    '; should be ',0
  336. SS6       DB    'BUG: Sum = ',0
  337. SS5       DB    'Sum = ',0
  338. SS4       DB    'Enter upper ',0
  339. SS3       DB    ' Problem: ',0
  340. SS2       DB    ' K: ',0
  341. SS1       DB    ' J: ',0
  342. SS0       DB    'I: ',0
  343.           ENDP
  344.  ;    SYMBOL TABLE
  345.  ; MAIN                            8[BP]
  346.  ; SUM                             6[BP]
  347.  ; UPPER                           4[BP]
  348.  
  349.  ; 
  350.  ; GLOBAL VARIABLES
  351. PROBLEM   DW    0
  352. I         DW    0
  353. J         DW    0
  354. K         DW    0
  355.  ; RUNTIME STACK
  356.           DS    2000
  357. STACKORG  DW    0
  358.  ; MAIN stack space
  359.           DW    0
  360.           DW    0
  361.           DW    0
  362. ; NO errors
  363.