API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 15th, 2023
181
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 84.42 KB | None | 0 0
raw download clone embed print report
  1. .MODEL SMALL
  2. .STACK 100h
  3. .DATA
  4. .386
  5.  
  6.  
  7. ;MAIN MENU
  8. m_dis1 db "Title: BASE 8,10,16 CALCULATOR & CONVERSION$"
  9. m_dis2 db "Name: Ignacio, Mary Catherine & Ofracio, Earl John$"
  10. m_dis3 db "MAIN MENU$"
  11. m_dis4 db "[1] Calculator $"
  12. m_dis5 db "[2] Conversion $"
  13. m_dis6 db "[9] Exit$"
  14. m_dis10 db "Pick your choice: $"
  15.  
  16. ;CALCULATOR SUB-MENU
  17. cal_menu1 db "CALCULATOR$"
  18. cal_menu2 db "[1] Addition $"
  19. cal_menu3 db "[2] Subtraction $"
  20. cal_menu4 db "[3] Multiplication $"
  21. cal_menu5 db "[4] Division $"
  22. cal_menu6 db "[5] Modulo $"
  23. cal_menu7 db "[9] Back to Main Menu$"
  24.  
  25. ;CALCULATOR MENU
  26. cal_header_add db "Calculator : ADDITION$"
  27. cal_header_sub db "Calculator : SUBTRACTION$"
  28. cal_header_mul db "Calculator : MULTIPLICATION$"
  29. cal_header_div db "Calculator : DIVISION$"
  30. cal_header_mod db "Calculator : MODULO$"
  31. cal_choice1 db "[1] Base 08$"
  32. cal_choice2 db "[2] Base 10$"
  33. cal_choice3 db "[3] Base 16$"
  34. cal_choice4 db "[9] Back to Sub Menu$"
  35.  
  36. ;ADDITION
  37. add_header_base8 db "BASE 8 ADDITION$"
  38. add_header_base10 db "BASE 10 ADDITION$"
  39. add_header_base16 db "BASE 16 ADDITION$"
  40. add_input_1_8 db "Addend [0-0.777]: 0.$"
  41. add_input_2_8 db "Augend [0-0.777]: 0.$"
  42. add_input_1_10 db "Addend [0-0.999]: 0.$"
  43. add_input_2_10 db "Augend [0-0.999]: 0.$"
  44. add_input_1_16 db "Addend [0-0.FFF]: 0.$"
  45. add_input_2_16 db "Augend [0-0.FFF]: 0.$"
  46. add_ans db "Sum is : $"
  47. add_again db "Add Again? [Y/N]: $"
  48.  
  49. ;SUBTRACTION
  50. sub_header_base8 db "BASE 8 SUBTRACTION$"
  51. sub_header_base10 db "BASE 10 SUBTRACTION$"
  52. sub_header_base16 db "BASE 16 SUBTRACTION$"
  53. sub_input_1_8 db "Minuend [0-0.777]: 0.$"
  54. sub_input_2_8 db "Subtrahend [0-0.777]: 0.$"
  55. sub_input_1_10 db "Minuend [0-0.999]: 0.$"
  56. sub_input_2_10 db "Subtrahend [0-0.999]: 0.$"
  57. sub_input_1_16 db "Minuend [0-0.FFF]: 0.$"
  58. sub_input_2_16 db "Subtrahend [0-0.FFF]: 0.$"
  59. sub_ans db "Difference is : $"
  60. sub_again db "Subtract Again?[Y/N]: $"
  61.  
  62. ;MULTIPLICATION
  63. mul_header_base8 db "BASE 8 MULTIPLICATION$"
  64. mul_header_base10 db "BASE 10 MULTIPLICATION$"
  65. mul_header_base16 db "BASE 16 MULTIPLICATION$"
  66. mul_input_1_8 db "Multiplicand [0-0.777]: 0.$"
  67. mul_input_2_8 db "Multiplier [0-0.777]: 0.$"
  68. mul_input_1_10 db "Multiplicand [0-0.999]: 0.$"
  69. mul_input_2_10 db "Multiplier [0-0.999]: 0.$"
  70. mul_input_1_16 db "Multiplicand [0-0.FFF]: 0.$"
  71. mul_input_2_16 db "Multiplier [0-0.FFF]: 0.$"
  72. mul_ans db "Product is: 0.$"
  73. mul_again db "Multiply Again? [Y/N]: $"
  74.  
  75. ;DIVISION
  76. div_header_base8 db "BASE 8 DIVISION$"
  77. div_header_base10 db "BASE 10 DIVISION$"
  78. div_header_base16 db "BASE 16 DIVISION$"
  79. div_input_1_8 db "Dividend [0-0.777]: 0.$"
  80. div_input_2_8 db "Divisor [0-0.777]: 0.$"
  81. div_input_1_10 db "Dividend [0-0.999]: 0.$"
  82. div_input_2_10 db "Divisor [0-0.999]: 0.$"
  83. div_input_1_16 db "Dividend [0-0.FFF]: 0.$"
  84. div_input_2_16 db "Divisor [0-0.FFF]: 0.$"
  85. div_ans db "Qoutient is : $"
  86. div_again db "Divide Again? [Y/N]: $"
  87. ;MODULO
  88. mod_header_base8 db "BASE 8 MODULO$"
  89. mod_header_base10 db "BASE 10 MODULO$"
  90. mod_header_base16 db "BASE 16 MODULO$"
  91. mod_input_1_8 db "Dividend [0-0.777] : 0.$"
  92. mod_input_2_8 db "Divisor [0-0.777] : 0.$"
  93. mod_input_1_10 db "Dividend [0-0.999] : 0.$"
  94. mod_input_2_10 db "Divisor [0-0.999] : 0.$"
  95. mod_input_1_16 db "Dividend [0-0.FFF] : 0.$"
  96. mod_input_2_16 db "Divisor [0-0.FFF] : 0.$"
  97. mod_ans db "Remainder is: 0.0$"
  98. mod_again db "Divide Again? [Y/N]: $"
  99. ;CONVERSION SUB-MENU
  100. con_menu1 db "CONVERSION SUB-MENU$"
  101. con_menu2 db "[1] Base 08 to Base 10 $"
  102. con_menu3 db "[2] Base 08 to Base 16$"
  103. con_menu4 db "[3] Base 10 to Base 08 $"
  104. con_menu5 db "[4] Base 10 to Base 16 $"
  105. con_menu6 db "[5] Base 16 to Base 08 $"
  106. con_menu7 db "[6] Base 16 to Base 10 $"
  107. con_menu8 db "[9] Back to Main Menu$"
  108. con_menu9 db "Enter a Choice: $"
  109.  
  110. ;CONVERSION 08 TO 10
  111. con_header_08_10 db "CONVERSION: BASE 08 TO BASE 10 $"
  112. con_input_08_10 db "Base 08 [0-0.777] : 0.$"
  113. con_ans_08_10 db "Base 10 Equivalent : 0.$"
  114. con_again db "Convert Again? [Y/N] : $"
  115.  
  116. ;CONVERSION 08 TO 16
  117. con_header_08_16 db "CONVERSION: BASE 08 TO BASE 16 $"
  118. con_input_08_16 db "Base 08 [0-0.777] : 0.$"
  119. con_ans_08_16 db "Base 16 Equivalent : 0.$"
  120.  
  121. ;CONVERSION 10 TO 08
  122. con_header_10_08 db "CONVERSION: BASE 10 TO BASE 08 $"
  123. con_input_10_08 db "Base 10 [0-0.999] : 0.$"
  124. con_ans_10_08 db "Base 08 Equivalent : 0.$"
  125.  
  126. ;CONVERSION 10 TO 16
  127. con_header_10_16 db "CONVERSION: BASE 10 TO BASE 16 $"
  128. con_input_10_16 db "Base 10 [0-0.999] : 0.$"
  129. con_ans_10_16 db "Base 16 Equivalent : 0.$"
  130.  
  131. ;CONVERSION 16 TO 08
  132. con_header_16_08 db "CONVERSION: BASE 16 TO BASE 08 $"
  133. con_input_16_08 db "Base 16 [0-0.FFF] : 0.$"
  134. con_ans_16_08 db "Base 08 Equivalent : 0.$"
  135.  
  136. ;CONVERSION 16 TO 10
  137. con_header_16_10 db "CONVERSION: BASE 16 TO BASE 10 $"
  138. con_input_16_10 db "Base 16 [0-0.FFF] : 0.$"
  139. con_ans_16_10 db "Base 10 Equivalent : 0.$"
  140.  
  141. ;EXIT
  142. exit_dis1 db "THANK YOUR FOR USING THE SYSTEM$"
  143. exit_dis2 db "BASE 8,10,16 CALCULATOR & CONVERSION$"
  144. exit_dis3 db "CREATED By:$"
  145. exit_dis4 db "Ignacio, Mary Catherine$"
  146. exit_dis5 db "Ofracio, Earl John$"
  147.  
  148. ;LINES
  149. line_1 db "====================================================$"
  150. line_3 db "____________________________________________________$"
  151. line_2 db "----------------------------------------------------$"
  152. ;WARNINGS
  153. war_invalid db "Invalid input $"
  154. war_press db "Press any key to continue.$"
  155. war_input db "There is an error in your inputted number$"
  156.  
  157. .code
  158. main proc
  159.  
  160.  
  161. mov ax,@data
  162. mov ds,ax
  163.  
  164. ; /Display the main menu
  165. call CENTER_CLEAR
  166. mov ah,02h
  167. mov dx,010Fh
  168. int 10h
  169. mov ah,09h
  170. lea dx, line_1
  171. int 21h
  172.  
  173. mov ah,02h
  174. mov dx,020Fh
  175. int 10h
  176. mov ah,09h
  177. lea dx, m_dis1
  178. int 21h
  179.  
  180. mov ah,02h
  181. mov dx,040Fh
  182. int 10h
  183. mov ah,09h
  184. lea dx, m_dis2
  185. int 21h
  186.  
  187. mov ah,02h
  188. mov dx,050Fh
  189. int 10h
  190. mov ah,09h
  191. lea dx, line_1
  192. int 21h
  193.  
  194. mov ah,02h
  195. mov dx,0625h
  196. int 10h
  197. mov ah,09h
  198. lea dx, m_dis3
  199. int 21h
  200.  
  201. mov ah,02h
  202. mov dx,070Fh
  203. int 10h
  204. mov ah,09h
  205. lea dx, line_1
  206. int 21h
  207.  
  208. mov ah,02h
  209. mov dx,0923h
  210. int 10h
  211. mov ah,09h
  212. lea dx, m_dis4
  213. int 21h
  214.  
  215. mov ah,02h
  216. mov dx,0A23h
  217. int 10h
  218. mov ah,09h
  219. lea dx, m_dis5
  220. int 21h
  221.  
  222. mov ah,02h
  223. mov dx,0B23h
  224. int 10h
  225. mov ah,09h
  226. lea dx, m_dis6
  227. int 21h
  228.  
  229. mov ah,02h
  230. mov dx,0D0Fh
  231. int 10h
  232. mov ah,09h
  233. lea dx, line_2
  234. int 21h
  235.  
  236. mov ah,02h
  237. mov dx,0F23h
  238. int 10h
  239. mov ah,09h
  240. lea dx, m_dis10
  241. int 21h
  242.  
  243. main_menu_conf:
  244. mov ah,08h
  245. int 21h
  246. cmp al,'1'
  247. je open_cal
  248. cmp al,'2'
  249. je open_con
  250. cmp al,'9'
  251. je close_app
  252. jmp main_menu_conf
  253.  
  254.  
  255.  
  256. open_cal: call CAL_MENU
  257. open_con: call CON_MENU
  258. close_app: call TERMINATE
  259.  
  260. endp main
  261.  
  262. CAL_MENU proc
  263. call CENTER_CLEAR
  264.  
  265. mov ah,02h
  266. mov dx,010Fh
  267. int 10h
  268. mov ah,09h
  269. lea dx, line_1
  270. int 21h
  271.  
  272. mov ah,02h
  273. mov dx,0225h
  274. int 10h
  275. mov ah,09h
  276. lea dx, cal_menu1
  277. int 21h
  278.  
  279. mov ah,02h
  280. mov dx,030Fh
  281. int 10h
  282. mov ah,09h
  283. lea dx, line_1
  284. int 21h
  285.  
  286. mov ah,02h
  287. mov dx,0522h
  288. int 10h
  289. mov ah,09h
  290. lea dx, cal_menu2
  291. int 21h
  292.  
  293. mov ah,02h
  294. mov dx,0622h
  295. int 10h
  296. mov ah,09h
  297. lea dx, cal_menu3
  298. int 21h
  299.  
  300. mov ah,02h
  301. mov dx,0722h
  302. int 10h
  303. mov ah,09h
  304. lea dx, cal_menu4
  305. int 21h
  306.  
  307. mov ah,02h
  308. mov dx,0822h
  309. int 10h
  310. mov ah,09h
  311. lea dx, cal_menu5
  312. int 21h
  313.  
  314. mov ah,02h
  315. mov dx,0922h
  316. int 10h
  317. mov ah,09h
  318. lea dx, cal_menu6
  319. int 21h
  320.  
  321. mov ah,02h
  322. mov dx,0A22h
  323. int 10h
  324. mov ah,09h
  325. lea dx, cal_menu7
  326. int 21h
  327.  
  328. mov ah,02h
  329. mov dx,0C0Fh
  330. int 10h
  331. mov ah,09h
  332. lea dx, line_2
  333. int 21h
  334.  
  335. mov ah,02h
  336. mov dx,0E22h
  337. int 10h
  338. mov ah,09h
  339. lea dx, m_dis10
  340. int 21h
  341.  
  342. cal_menu_conf:
  343. mov ah,08h
  344. int 21h
  345. cmp al,'1'
  346. je go_menu_add
  347. cmp al, '2'
  348. je go_menu_sub
  349. cmp al, '3'
  350. je go_menu_mul
  351. cmp al, '4'
  352. je go_menu_div
  353. cmp al, '5'
  354. je go_menu_mod
  355. cmp al, '9'
  356. je go_menu
  357. jmp cal_menu_conf
  358.  
  359.  
  360. go_menu_add: call CAL_MENU_ADD
  361. go_menu_sub: call CAL_MENU_SUB
  362. go_menu_mul: call CAL_MENU_MUL
  363. go_menu_div: call CAL_MENU_DIV
  364. go_menu_mod: call CAL_MENU_MOD
  365. go_menu: call main
  366.  
  367. CAL_MENU endp
  368. ; Calculator Functions - Addition
  369. CAL_MENU_ADD proc
  370. call CENTER_CLEAR
  371.  
  372. mov ah,02h
  373. mov dx,010Fh
  374. int 10h
  375. mov ah,09h
  376. lea dx, line_1
  377. int 21h
  378.  
  379. mov ah,02h
  380. mov dx,021Eh
  381. int 10h
  382. mov ah,09h
  383. lea dx, cal_header_add
  384. int 21h
  385.  
  386. mov ah,02h
  387. mov dx,030Fh
  388. int 10h
  389. mov ah,09h
  390. lea dx, line_1
  391. int 21h
  392.  
  393. mov ah,02h
  394. mov dx,0523h
  395. int 10h
  396. mov ah,09h
  397. lea dx, cal_choice1
  398. int 21h
  399.  
  400. mov ah,02h
  401. mov dx,0623h
  402. int 10h
  403. mov ah,09h
  404. lea dx, cal_choice2
  405. int 21h
  406.  
  407. mov ah,02h
  408. mov dx,0723h
  409. int 10h
  410. mov ah,09h
  411. lea dx, cal_choice3
  412. int 21h
  413.  
  414. mov ah,02h
  415. mov dx,0823h
  416. int 10h
  417. mov ah,09h
  418. lea dx, cal_choice4
  419. int 21h
  420.  
  421. mov ah,02h
  422. mov dx,0A0Fh
  423. int 10h
  424. mov ah,09h
  425. lea dx, line_2
  426. int 21h
  427.  
  428. mov ah,02h
  429. mov dx,0C22h
  430. int 10h
  431. mov ah,09h
  432. lea dx, m_dis10
  433. int 21h
  434.  
  435. cal_add_conf:
  436. mov ah,08h
  437. int 21h
  438. cmp al,'1'
  439. je add_base8
  440. cmp al, '2'
  441. je add_base10
  442. cmp al, '3'
  443. je add_base16
  444. cmp al, '9'
  445. je add_back
  446.  
  447. jmp cal_add_conf
  448.  
  449. add_base8: call CAL_ADD_8
  450. add_base10: call CAL_ADD_10
  451. add_base16: call CAL_ADD_16
  452. add_back: call CAL_MENU
  453.  
  454. CAL_MENU_ADD endp
  455.  
  456. CAL_ADD_8 proc
  457.  
  458. start_input_8:
  459. call CENTER_CLEAR
  460.  
  461. mov ah,02h
  462. mov dx,010Fh
  463. int 10h
  464. mov ah,09h
  465. lea dx, line_1
  466. int 21h
  467.  
  468. mov ah,02h
  469. mov dx,0223h
  470. int 10h
  471. mov ah,09h
  472. lea dx, add_header_base8
  473. int 21h
  474.  
  475. mov ah,02h
  476. mov dx,030Fh
  477. int 10h
  478. mov ah,09h
  479. lea dx, line_1
  480. int 21h
  481.  
  482. mov ah,02h
  483. mov dx,051Dh
  484. int 10h
  485. mov ah,09h
  486. lea dx, add_input_1_8
  487. int 21h
  488.  
  489. ;1st 3 Inputs
  490. mov cl,03h
  491. add_8_input_1:
  492. mov ah,01
  493. int 21h
  494. cmp al, '0'
  495. jl start_input_8
  496. cmp al, '8'
  497. jge start_input_8
  498. call DEC_AL
  499. push ax
  500. loop add_8_input_1
  501.  
  502. mov ah,02h
  503. mov dx,061Dh
  504. int 10h
  505. mov ah,09h
  506. lea dx, add_input_2_8
  507. int 21h
  508.  
  509. ;2nd 3 Inputs
  510. mov cl,03h
  511. add_8_input_2:
  512. mov ah,01
  513. int 21h
  514. cmp al, '0'
  515. jl start_input_8
  516. cmp al, '8'
  517. jge start_input_8
  518. call DEC_AL
  519. push ax
  520. loop add_8_input_2
  521.  
  522. mov ah,02h
  523. mov dx,071Dh
  524. int 10h
  525. mov ah,09h
  526. lea dx, add_ans
  527. int 21h
  528.  
  529. ;Logic FOR BASE 8 Addition
  530. pop bx
  531. pop cx
  532. pop dx
  533. mov dh,dl
  534.  
  535. pop ax
  536. add bl, al
  537.  
  538. pop ax
  539. add cl, al
  540.  
  541. pop ax
  542. add dh, al
  543.  
  544. cmp bl, 08h
  545. jge cr_ones
  546.  
  547. chk_tens:
  548. cmp cl, 08h
  549. jge cr_tens
  550.  
  551. chk_hunds:
  552. cmp dl, 08h
  553. jge cr_hunds
  554.  
  555. cmp dh, 08h
  556. jge cr_hunds
  557.  
  558. mov dl, 30h
  559.  
  560. out_ans:
  561.  
  562. mov ah,02h
  563.  
  564. add bl, 30h
  565. add cl, 30h
  566. add dh, 30h
  567.  
  568. int 21h
  569. mov dl, 2Eh
  570. int 21h
  571. mov dl, dh
  572. int 21h
  573. mov dl, cl
  574. int 21h
  575. mov dl, bl
  576. int 21h
  577.  
  578. jmp add_8_confirm
  579.  
  580. cr_ones:
  581. inc cl
  582. sub bl, 08h
  583. jmp chk_tens
  584.  
  585. cr_tens:
  586. inc dh
  587. sub cl, 08h
  588. jmp chk_hunds
  589.  
  590. cr_hunds:
  591. sub dh,08h
  592. mov dl,31h
  593. jmp out_ans
  594.  
  595.  
  596. ;/ Ask input to confirm if to try again.
  597.  
  598. add_8_confirm:
  599. call CENTER
  600.  
  601. mov ah,02h
  602. mov dx,090Fh
  603. int 10h
  604. mov ah,09h
  605. lea dx, line_2
  606. int 21h
  607.  
  608. mov ah,02h
  609. mov dx,0B20h
  610. int 10h
  611. mov ah,09h
  612. lea dx, add_again
  613. int 21h
  614.  
  615. add_8_yn_filter:
  616. mov ah,08h
  617. int 21h
  618. cmp al, 'Y'
  619. je add_start_8
  620. cmp al, 'y'
  621. je add_start_8
  622. cmp al, 'N'
  623. je add_end_8
  624. cmp al, 'n'
  625. je add_end_8
  626. jmp add_8_yn_filter
  627.  
  628. add_start_8: call CAL_ADD_8
  629. add_end_8: call CAL_MENU_ADD
  630.  
  631. CAL_ADD_8 endp
  632.  
  633. CAL_ADD_10 proc
  634.  
  635. start_input_10:
  636. call CENTER_CLEAR
  637.  
  638. mov ah,02h
  639. mov dx,010Fh
  640. int 10h
  641. mov ah,09h
  642. lea dx, line_1
  643. int 21h
  644.  
  645. mov ah,02h
  646. mov dx,0223h
  647. int 10h
  648. mov ah,09h
  649. lea dx, add_header_base10
  650. int 21h
  651.  
  652. mov ah,02h
  653. mov dx,030Fh
  654. int 10h
  655. mov ah,09h
  656. lea dx, line_1
  657. int 21h
  658.  
  659. mov ah,02h
  660. mov dx,051Dh
  661. int 10h
  662. mov ah,09h
  663. lea dx, add_input_1_10
  664. int 21h
  665.  
  666. ;1st 3 Inputs
  667. mov cl,03h
  668. add_10_input_1:
  669. mov ah,01
  670. int 21h
  671. cmp al, '0'
  672. jl start_input_10
  673. cmp al, '9'
  674. jg start_input_10
  675. call DEC_AL
  676. push ax
  677. loop add_10_input_1
  678.  
  679. mov ah,02h
  680. mov dx,061Dh
  681. int 10h
  682. mov ah,09h
  683. lea dx, add_input_2_10
  684. int 21h
  685.  
  686. ;2nd 3 Inputs
  687. mov cl,03h
  688. add_10_input_2:
  689. mov ah,01
  690. int 21h
  691. cmp al, '0'
  692. jl start_input_10
  693. cmp al, '9'
  694. jg start_input_10
  695. call DEC_AL
  696. push ax
  697. loop add_10_input_2
  698.  
  699. mov ah,02h
  700. mov dx,071Dh
  701. int 10h
  702. mov ah,09h
  703. lea dx, add_ans
  704. int 21h
  705.  
  706. ;Logic FOR BASE 10 Addition
  707. pop bx
  708. pop cx
  709. pop dx
  710. mov dh,dl
  711.  
  712. pop ax
  713. add bl, al
  714.  
  715. pop ax
  716. add cl, al
  717.  
  718. pop ax
  719. add dh, al
  720.  
  721. cmp bl, 0Ah
  722. jge cr_ones_10
  723.  
  724. chk_tens_10:
  725. cmp cl, 0Ah
  726. jge cr_tens_10
  727.  
  728. chk_hunds_10:
  729. cmp dl, 0Ah
  730. jge cr_hunds_10
  731.  
  732. cmp dh, 0Ah
  733. jge cr_hunds_10
  734.  
  735. mov dl, 30h
  736.  
  737. out_ans_10:
  738.  
  739. mov ah,02h
  740.  
  741. add bl, 30h
  742. add cl, 30h
  743. add dh, 30h
  744.  
  745. int 21h
  746. mov dl, 2Eh
  747. int 21h
  748. mov dl, dh
  749. int 21h
  750. mov dl, cl
  751. int 21h
  752. mov dl, bl
  753. int 21h
  754.  
  755. jmp add_10_confirm
  756.  
  757.  
  758. cr_ones_10:
  759. inc cl
  760. sub bl, 0Ah
  761. jmp chk_tens_10
  762.  
  763. cr_tens_10:
  764. inc dh
  765. sub cl, 0Ah
  766. jmp chk_hunds_10
  767.  
  768. cr_hunds_10:
  769. sub dh,0Ah
  770. mov dl,31h
  771. jmp out_ans_10
  772.  
  773.  
  774. ;/ Ask input to confirm if to try again.
  775.  
  776. add_10_confirm:
  777. call CENTER
  778.  
  779. mov ah,02h
  780. mov dx,090Fh
  781. int 10h
  782. mov ah,09h
  783. lea dx, line_2
  784. int 21h
  785.  
  786. mov ah,02h
  787. mov dx,0B20h
  788. int 10h
  789. mov ah,09h
  790. lea dx, add_again
  791. int 21h
  792.  
  793. add_10_yn_filter:
  794. mov ah,08h
  795. int 21h
  796. cmp al, 'Y'
  797. je add_start_10
  798. cmp al, 'y'
  799. je add_start_10
  800. cmp al, 'N'
  801. je add_end_10
  802. cmp al, 'n'
  803. je add_end_10
  804. jmp add_10_yn_filter
  805.  
  806. add_start_10: call CAL_ADD_10
  807. add_end_10: call CAL_MENU_ADD
  808.  
  809. CAL_ADD_10 endp
  810.  
  811. CAL_ADD_16 proc
  812.  
  813. start_input_16:
  814. call CENTER_CLEAR
  815.  
  816. mov ah,02h
  817. mov dx,010Fh
  818. int 10h
  819. mov ah,09h
  820. lea dx, line_1
  821. int 21h
  822.  
  823. mov ah,02h
  824. mov dx,0223h
  825. int 10h
  826. mov ah,09h
  827. lea dx, add_header_base16
  828. int 21h
  829.  
  830. mov ah,02h
  831. mov dx,030Fh
  832. int 10h
  833. mov ah,09h
  834. lea dx, line_1
  835. int 21h
  836.  
  837. mov ah,02h
  838. mov dx,051Dh
  839. int 10h
  840. mov ah,09h
  841. lea dx, add_input_1_16
  842. int 21h
  843.  
  844. ;1st 3 Inputs
  845. mov cl,03h
  846. add_16_input_1:
  847. mov ah,01
  848. int 21h
  849. cmp al, 30h
  850. jl start_input_16
  851. cmp al, 46h
  852. jg start_input_16
  853. cmp al, 3ah
  854. jb valid_add_1
  855. cmp al, 41h
  856. jl start_input_16
  857. cmp al, 46h
  858. jle valid_add_1
  859. valid_add_1:
  860. call DEC_AL
  861. push ax
  862. loop add_16_input_1
  863.  
  864. mov ah,02h
  865. mov dx,061Dh
  866. int 10h
  867. mov ah,09h
  868. lea dx, add_input_2_16
  869. int 21h
  870.  
  871. ;2nd 3 Inputs
  872. mov cl,03h
  873. add_16_input_2:
  874. mov ah,01
  875. int 21h
  876. cmp al, 30h
  877. jl start_input_16
  878. cmp al, 46h
  879. jg start_input_16
  880. cmp al, 3ah
  881. jb valid_add_2
  882. cmp al, 41h
  883. jl start_input_16
  884. cmp al, 46h
  885. jle valid_add_2
  886. valid_add_2:
  887. call DEC_AL
  888. push ax
  889. loop add_16_input_2
  890.  
  891. mov ah,02h
  892. mov dx,071Dh
  893. int 10h
  894. mov ah,09h
  895. lea dx, add_ans
  896. int 21h
  897.  
  898. ;Logic FOR BASE 16 Addition
  899. pop ax
  900. mov bl,al
  901. pop ax
  902. mov bh,al
  903. pop ax
  904. mov cl,al
  905.  
  906. SHL BH, 4
  907. OR BL, BH
  908. MOV BH, CL
  909.  
  910. pop ax
  911. mov dl,al
  912. pop ax
  913. mov dh,al
  914. pop ax
  915. mov cl,al
  916.  
  917. SHL DH, 4
  918. OR DL,DH
  919. MOV DH, CL
  920.  
  921. clc
  922. adc bx,dx
  923. mov dx,0000
  924.  
  925. mov dh, bh ; will be used for comparison
  926.  
  927. and bh,0Fh ; Left over will be the hundreds
  928. mov al,bh
  929. call ASCII_AL
  930. mov bh,al
  931.  
  932. mov dl, bl
  933. SHR dl, 4
  934. mov al,dl
  935. call ASCII_AL
  936. mov cl,al
  937.  
  938. and BL, 0Fh
  939. mov al,bl
  940. call ASCII_AL
  941. mov bl,al
  942.  
  943. cmp dh, 0Fh
  944. jg has_carry
  945. jle no_carry
  946.  
  947. has_carry:
  948. mov ah,02h
  949. mov dl,31h
  950. int 21h
  951. mov dl,2Eh
  952. int 21h
  953. mov dl,bh
  954. int 21h
  955. mov dl,cl
  956. int 21h
  957. mov dl,bl
  958. int 21h
  959. jmp add_16_confirm
  960.  
  961. no_carry:
  962. mov ah,02h
  963. mov dl,30h
  964. int 21h
  965. mov dl,2Eh
  966. int 21h
  967. mov dl,bh
  968. int 21h
  969. mov dl,cl
  970. int 21h
  971. mov dl,bl
  972. int 21h
  973. jmp add_16_confirm
  974.  
  975. ;/ Ask input to confirm if to try again.
  976.  
  977. add_16_confirm:
  978. call CENTER
  979.  
  980. mov ah,02h
  981. mov dx,090Fh
  982. int 10h
  983. mov ah,09h
  984. lea dx, line_2
  985. int 21h
  986.  
  987. mov ah,02h
  988. mov dx,0B20h
  989. int 10h
  990. mov ah,09h
  991. lea dx, add_again
  992. int 21h
  993.  
  994. add_16_yn_filter:
  995. mov ah,08h
  996. int 21h
  997. cmp al, 'Y'
  998. je add_start_16
  999. cmp al, 'y'
  1000. je add_start_16
  1001. cmp al, 'N'
  1002. je add_end_16
  1003. cmp al, 'n'
  1004. je add_end_16
  1005. jmp add_16_yn_filter
  1006.  
  1007. add_start_16: call CAL_ADD_16
  1008. add_end_16: call CAL_MENU_ADD
  1009.  
  1010. CAL_ADD_16 endp
  1011.  
  1012. ; Calculator Functions - Subtraction
  1013. CAL_MENU_SUB proc
  1014. call CENTER_CLEAR
  1015.  
  1016. mov ah,02h
  1017. mov dx,010Fh
  1018. int 10h
  1019. mov ah,09h
  1020. lea dx, line_1
  1021. int 21h
  1022.  
  1023. mov ah,02h
  1024. mov dx,021Eh
  1025. int 10h
  1026. mov ah,09h
  1027. lea dx, cal_header_sub
  1028. int 21h
  1029.  
  1030. mov ah,02h
  1031. mov dx,030Fh
  1032. int 10h
  1033. mov ah,09h
  1034. lea dx, line_1
  1035. int 21h
  1036.  
  1037. mov ah,02h
  1038. mov dx,0523h
  1039. int 10h
  1040. mov ah,09h
  1041. lea dx, cal_choice1
  1042. int 21h
  1043.  
  1044. mov ah,02h
  1045. mov dx,0623h
  1046. int 10h
  1047. mov ah,09h
  1048. lea dx, cal_choice2
  1049. int 21h
  1050.  
  1051. mov ah,02h
  1052. mov dx,0723h
  1053. int 10h
  1054. mov ah,09h
  1055. lea dx, cal_choice3
  1056. int 21h
  1057.  
  1058. mov ah,02h
  1059. mov dx,0823h
  1060. int 10h
  1061. mov ah,09h
  1062. lea dx, cal_choice4
  1063. int 21h
  1064.  
  1065. mov ah,02h
  1066. mov dx,0A0Fh
  1067. int 10h
  1068. mov ah,09h
  1069. lea dx, line_2
  1070. int 21h
  1071.  
  1072. mov ah,02h
  1073. mov dx,0C22h
  1074. int 10h
  1075. mov ah,09h
  1076. lea dx, m_dis10
  1077. int 21h
  1078.  
  1079. cal_sub_conf:
  1080. mov ah,08h
  1081. int 21h
  1082. cmp al,'1'
  1083. je sub_base8
  1084. cmp al, '2'
  1085. je sub_base10
  1086. cmp al, '3'
  1087. je sub_base16
  1088. cmp al, '9'
  1089. je sub_back
  1090.  
  1091. jmp cal_sub_conf
  1092.  
  1093. sub_base8: call CAL_SUB_8
  1094. sub_base10: call CAL_SUB_10
  1095. sub_base16: call CAL_SUB_16
  1096. sub_back: call CAL_MENU
  1097.  
  1098. CAL_MENU_SUB endp
  1099.  
  1100. CAL_SUB_8 proc
  1101.  
  1102. sub_start_input_8:
  1103. call CENTER_CLEAR
  1104.  
  1105. mov ah,02h
  1106. mov dx,010Fh
  1107. int 10h
  1108. mov ah,09h
  1109. lea dx, line_1
  1110. int 21h
  1111.  
  1112. mov ah,02h
  1113. mov dx,0223h
  1114. int 10h
  1115. mov ah,09h
  1116. lea dx, sub_header_base8
  1117. int 21h
  1118.  
  1119. mov ah,02h
  1120. mov dx,030Fh
  1121. int 10h
  1122. mov ah,09h
  1123. lea dx, line_1
  1124. int 21h
  1125.  
  1126. mov ah,02h
  1127. mov dx,051Dh
  1128. int 10h
  1129. mov ah,09h
  1130. lea dx, sub_input_1_8
  1131. int 21h
  1132.  
  1133. ;1st 3 Inputs
  1134. mov cl,03h
  1135. sub_8_input_1:
  1136. mov ah,01
  1137. int 21h
  1138. cmp al, '0'
  1139. jl sub_start_input_8
  1140. cmp al, '8'
  1141. jge sub_start_input_8
  1142. call DEC_AL
  1143. push ax
  1144. loop sub_8_input_1
  1145.  
  1146. mov ah,02h
  1147. mov dx,061Dh
  1148. int 10h
  1149. mov ah,09h
  1150. lea dx, sub_input_2_8
  1151. int 21h
  1152.  
  1153. ;2nd 3 Inputs
  1154. mov cl,03h
  1155. sub_8_input_2:
  1156. mov ah,01
  1157. int 21h
  1158. cmp al, '0'
  1159. jl sub_start_input_8
  1160. cmp al, '8'
  1161. jge sub_start_input_8
  1162. call DEC_AL
  1163. push ax
  1164. loop sub_8_input_2
  1165.  
  1166. mov ah,02h
  1167. mov dx,071Dh
  1168. int 10h
  1169. mov ah,09h
  1170. lea dx, sub_ans
  1171. int 21h
  1172.  
  1173. ;Logic FOR BASE 8 Subtraction
  1174.  
  1175. pop ax
  1176. mov dl,al
  1177. pop ax
  1178. mov dh,al
  1179. pop ax
  1180. mov cl,al
  1181.  
  1182. SHL DH, 4
  1183. OR DL,DH
  1184. MOV DH, CL
  1185.  
  1186. pop ax
  1187. mov bl,al
  1188. pop ax
  1189. mov bh,al
  1190. pop ax
  1191. mov cl,al
  1192.  
  1193. SHL BH, 4
  1194. OR BL, BH
  1195. MOV BH, CL
  1196.  
  1197. cmp bx,dx ; compare if bx is greater than dx if not then go to negative_sub_8
  1198. jge positive_sub_8
  1199. jl negative_sub_8
  1200.  
  1201. positive_sub_8:
  1202. clc
  1203. sbb bx,dx
  1204. jmp calc_dif_8
  1205.  
  1206. negative_sub_8:
  1207. clc
  1208. sbb dx,bx
  1209. mov bx,dx
  1210. mov si,01h
  1211. jmp calc_dif_8
  1212.  
  1213. calc_dif_8:
  1214.  
  1215. mov ah,09h
  1216. lea dx, sub_ans
  1217. int 21h
  1218.  
  1219. mov dx,0000
  1220.  
  1221. mov dh, bh ; will be used for comparison
  1222.  
  1223. and bh,0Fh ; Left over will be the hundreds
  1224. mov al,bh
  1225. call ASCII_AL
  1226. mov bh,al
  1227.  
  1228. mov dl, bl
  1229. SHR dl, 4
  1230. mov al,dl
  1231. call ASCII_AL
  1232. mov cl,al
  1233.  
  1234. and BL, 0Fh
  1235. mov al,bl
  1236. call ASCII_AL
  1237. mov bl,al
  1238.  
  1239. cmp si,01h
  1240. je neg_sign_8 ; negative sign for negative subtractions
  1241.  
  1242. cmp bh, 41h
  1243. jge con_hun_8
  1244.  
  1245. bk_con_hun_8:
  1246. cmp cl, 41h
  1247. jge con_ten_8
  1248.  
  1249. bk_con_ten_8:
  1250. cmp bl, 41h
  1251. jge con_one_8
  1252.  
  1253. chk_carry_8:
  1254. cmp dh, 0Fh
  1255. jg has_carry_sub_8
  1256. jle no_carry_sub_8
  1257.  
  1258. start_again_8:
  1259. jmp sub_start_input_8
  1260.  
  1261. con_hun_8:
  1262. sub bh, 0Dh
  1263. jmp bk_con_hun_8
  1264.  
  1265. con_ten_8:
  1266. sub cl, 0Dh
  1267. jmp bk_con_ten_8
  1268.  
  1269. con_one_8:
  1270. sub bl, 0Dh
  1271. jmp chk_carry_8
  1272.  
  1273.  
  1274. has_carry_sub_8:
  1275. mov ah,02h
  1276. mov dl,31h
  1277. int 21h
  1278. mov dl,2Eh
  1279. int 21h
  1280. mov dl,bh
  1281. int 21h
  1282. mov dl,cl
  1283. int 21h
  1284. mov dl,bl
  1285. int 21h
  1286.  
  1287. jmp sub_8_confirm
  1288.  
  1289. no_carry_sub_8:
  1290. mov ah,02h
  1291. mov dl,30h
  1292. int 21h
  1293. mov dl,2Eh
  1294. int 21h
  1295. mov dl,bh
  1296. int 21h
  1297. mov dl,cl
  1298. int 21h
  1299. mov dl,bl
  1300. int 21h
  1301.  
  1302. jmp sub_8_confirm
  1303.  
  1304.  
  1305. neg_sign_8:
  1306. mov si,00h
  1307. mov ah,02
  1308. mov dl,2Dh
  1309. int 21h
  1310. jmp no_carry_sub_8
  1311.  
  1312. ;/ Ask input to confirm if to try again.
  1313.  
  1314. sub_8_confirm:
  1315. call CENTER
  1316.  
  1317. mov ah,02h
  1318. mov dx,090Fh
  1319. int 10h
  1320. mov ah,09h
  1321. lea dx, line_2
  1322. int 21h
  1323.  
  1324. mov ah,02h
  1325. mov dx,0B20h
  1326. int 10h
  1327. mov ah,09h
  1328. lea dx, sub_again
  1329. int 21h
  1330.  
  1331. sub_8_yn_filter:
  1332. mov ah,08h
  1333. int 21h
  1334. cmp al, 'Y'
  1335. je sub_start_8
  1336. cmp al, 'y'
  1337. je sub_start_8
  1338. cmp al, 'N'
  1339. je sub_end_8
  1340. cmp al, 'n'
  1341. je sub_end_8
  1342. jmp sub_8_yn_filter
  1343.  
  1344. sub_start_8: call CAL_SUB_8
  1345. sub_end_8: call CAL_MENU_SUB
  1346.  
  1347. CAL_SUB_8 endp
  1348.  
  1349. CAL_SUB_10 proc
  1350.  
  1351. sub_start_input_10:
  1352. call CENTER_CLEAR
  1353.  
  1354. mov ah,02h
  1355. mov dx,010Fh
  1356. int 10h
  1357. mov ah,09h
  1358. lea dx, line_1
  1359. int 21h
  1360.  
  1361. mov ah,02h
  1362. mov dx,0223h
  1363. int 10h
  1364. mov ah,09h
  1365. lea dx, sub_header_base10
  1366. int 21h
  1367.  
  1368. mov ah,02h
  1369. mov dx,030Fh
  1370. int 10h
  1371. mov ah,09h
  1372. lea dx, line_1
  1373. int 21h
  1374.  
  1375. mov ah,02h
  1376. mov dx,051Dh
  1377. int 10h
  1378. mov ah,09h
  1379. lea dx, sub_input_1_10
  1380. int 21h
  1381.  
  1382. ;1st 3 Inputs
  1383. mov cl,03h
  1384. sub_10_input_1:
  1385. mov ah,01
  1386. int 21h
  1387. cmp al, '0'
  1388. jl sub_start_input_10
  1389. cmp al, '9'
  1390. jg sub_start_input_10
  1391. call DEC_AL
  1392. push ax
  1393. loop sub_10_input_1
  1394.  
  1395. mov ah,02h
  1396. mov dx,061Dh
  1397. int 10h
  1398. mov ah,09h
  1399. lea dx, sub_input_2_10
  1400. int 21h
  1401.  
  1402. ;2nd 3 Inputs
  1403. mov cl,03h
  1404. sub_10_input_2:
  1405. mov ah,01
  1406. int 21h
  1407. cmp al, '0'
  1408. jl sub_start_input_10
  1409. cmp al, '9'
  1410. jg sub_start_input_10
  1411. call DEC_AL
  1412. push ax
  1413. loop sub_10_input_2
  1414.  
  1415. mov ah,02h
  1416. mov dx,071Dh
  1417. int 10h
  1418. mov ah,09h
  1419. lea dx, sub_ans
  1420. int 21h
  1421.  
  1422. ;Logic FOR BASE 8 Subtraction
  1423.  
  1424. pop ax
  1425. mov dl,al
  1426. pop ax
  1427. mov dh,al
  1428. pop ax
  1429. mov cl,al
  1430.  
  1431. SHL DH, 4
  1432. OR DL,DH
  1433. MOV DH, CL
  1434.  
  1435. pop ax
  1436. mov bl,al
  1437. pop ax
  1438. mov bh,al
  1439. pop ax
  1440. mov cl,al
  1441.  
  1442. SHL BH, 4
  1443. OR BL, BH
  1444. MOV BH, CL
  1445.  
  1446. cmp bx,dx ; compare if bx is greater than dx if not then go to negative_sub_10
  1447. jge positive_sub_10
  1448. jl negative_sub_10
  1449.  
  1450. positive_sub_10:
  1451. clc
  1452. sbb bx,dx
  1453. jmp calc_dif_10
  1454.  
  1455. negative_sub_10:
  1456. clc
  1457. sbb dx,bx
  1458. mov bx,dx
  1459. mov si,01h
  1460. jmp calc_dif_10
  1461.  
  1462. calc_dif_10:
  1463.  
  1464. mov ah,09h
  1465. lea dx, sub_ans
  1466. int 21h
  1467.  
  1468. mov dx,0000
  1469.  
  1470. mov dh, bh ; will be used for comparison
  1471.  
  1472. and bh,0Fh ; Left over will be the hundreds
  1473. mov al,bh
  1474. call ASCII_AL
  1475. mov bh,al
  1476.  
  1477. mov dl, bl
  1478. SHR dl, 4
  1479. mov al,dl
  1480. call ASCII_AL
  1481. mov cl,al
  1482.  
  1483. and BL, 0Fh
  1484. mov al,bl
  1485. call ASCII_AL
  1486. mov bl,al
  1487.  
  1488. cmp si,01h
  1489. je neg_sign_10 ; negative sign for negative subtractions
  1490.  
  1491. cmp bh, 41h
  1492. jge con_hun_10
  1493.  
  1494. bk_con_hun_10:
  1495. cmp cl, 41h
  1496. jge con_ten_10
  1497.  
  1498. bk_con_ten_10:
  1499. cmp bl, 41h
  1500. jge con_one_10
  1501.  
  1502. chk_carry_10:
  1503. cmp dh, 0Fh
  1504. jg has_carry_sub_10
  1505. jle no_carry_sub_10
  1506.  
  1507. start_again_10:
  1508. jmp sub_start_input_10
  1509.  
  1510. con_hun_10:
  1511. sub bh, 0Dh
  1512. jmp bk_con_hun_10
  1513.  
  1514. con_ten_10:
  1515. sub cl, 0Dh
  1516. jmp bk_con_ten_10
  1517.  
  1518. con_one_10:
  1519. sub bl, 0Dh
  1520. jmp chk_carry_10
  1521.  
  1522.  
  1523. has_carry_sub_10:
  1524. mov ah,02h
  1525. mov dl,31h
  1526. int 21h
  1527. mov dl,2Eh
  1528. int 21h
  1529. mov dl,bh
  1530. int 21h
  1531. mov dl,cl
  1532. int 21h
  1533. mov dl,bl
  1534. int 21h
  1535.  
  1536. jmp sub_10_confirm
  1537.  
  1538. no_carry_sub_10:
  1539. mov ah,02h
  1540. mov dl,30h
  1541. int 21h
  1542. mov dl,2Eh
  1543. int 21h
  1544. mov dl,bh
  1545. int 21h
  1546. mov dl,cl
  1547. int 21h
  1548. mov dl,bl
  1549. int 21h
  1550.  
  1551. jmp sub_10_confirm
  1552.  
  1553.  
  1554. neg_sign_10:
  1555. mov si,00h
  1556. mov ah,02
  1557. mov dl,2Dh
  1558. int 21h
  1559. jmp no_carry_sub_10
  1560.  
  1561. ;/ Ask input to confirm if to try again.
  1562.  
  1563. sub_10_confirm:
  1564. call CENTER
  1565.  
  1566. mov ah,02h
  1567. mov dx,090Fh
  1568. int 10h
  1569. mov ah,09h
  1570. lea dx, line_2
  1571. int 21h
  1572.  
  1573. mov ah,02h
  1574. mov dx,0B20h
  1575. int 10h
  1576. mov ah,09h
  1577. lea dx, sub_again
  1578. int 21h
  1579.  
  1580. sub_10_yn_filter:
  1581. mov ah,08h
  1582. int 21h
  1583. cmp al, 'Y'
  1584. je sub_start_10
  1585. cmp al, 'y'
  1586. je sub_start_10
  1587. cmp al, 'N'
  1588. je sub_end_10
  1589. cmp al, 'n'
  1590. je sub_end_10
  1591. jmp sub_10_yn_filter
  1592.  
  1593. sub_start_10: call CAL_SUB_10
  1594. sub_end_10: call CAL_MENU_SUB
  1595.  
  1596. CAL_SUB_10 endp
  1597.  
  1598. CAL_SUB_16 proc
  1599. sub_start_input_16:
  1600. call CENTER_CLEAR
  1601.  
  1602. mov ah,02h
  1603. mov dx,010Fh
  1604. int 10h
  1605. mov ah,09h
  1606. lea dx, line_1
  1607. int 21h
  1608.  
  1609. mov ah,02h
  1610. mov dx,0223h
  1611. int 10h
  1612. mov ah,09h
  1613. lea dx, sub_header_base16
  1614. int 21h
  1615.  
  1616. mov ah,02h
  1617. mov dx,030Fh
  1618. int 10h
  1619. mov ah,09h
  1620. lea dx, line_1
  1621. int 21h
  1622.  
  1623. mov ah,02h
  1624. mov dx,051Dh
  1625. int 10h
  1626. mov ah,09h
  1627. lea dx, sub_input_1_16
  1628. int 21h
  1629.  
  1630. ;1st 3 Inputs
  1631. mov cl,03h
  1632. sub_16_input_1:
  1633. mov ah,01
  1634. int 21h
  1635. cmp al, 30h
  1636. jl sub_start_input_16
  1637. cmp al, 46h
  1638. jg sub_start_input_16
  1639. cmp al, 3ah
  1640. jb valid_sub_1
  1641. cmp al, 41h
  1642. jl sub_start_input_16
  1643. cmp al, 46h
  1644. jle valid_sub_1
  1645. valid_sub_1:
  1646. call DEC_AL
  1647. push ax
  1648. loop sub_16_input_1
  1649.  
  1650. mov ah,02h
  1651. mov dx,061Dh
  1652. int 10h
  1653. mov ah,09h
  1654. lea dx, sub_input_2_16
  1655. int 21h
  1656.  
  1657. ;2nd 3 Inputs
  1658. mov cl,03h
  1659. sub_16_input_2:
  1660. mov ah,01
  1661. int 21h
  1662. cmp al, 30h
  1663. jl sub_start_input_16
  1664. cmp al, 46h
  1665. jg sub_start_input_16
  1666. cmp al, 3ah
  1667. jb valid_sub_2
  1668. cmp al, 41h
  1669. jl sub_start_input_16
  1670. cmp al, 46h
  1671. jle valid_sub_2
  1672. valid_sub_2:
  1673. call DEC_AL
  1674. push ax
  1675. loop sub_16_input_2
  1676.  
  1677. mov ah,02h
  1678. mov dx,071Dh
  1679. int 10h
  1680. mov ah,09h
  1681. lea dx, sub_ans
  1682. int 21h
  1683.  
  1684. ;Logic FOR BASE 8 Subtraction
  1685.  
  1686. pop ax
  1687. mov dl,al
  1688. pop ax
  1689. mov dh,al
  1690. pop ax
  1691. mov cl,al
  1692.  
  1693. SHL DH, 4
  1694. OR DL,DH
  1695. MOV DH, CL
  1696.  
  1697. pop ax
  1698. mov bl,al
  1699. pop ax
  1700. mov bh,al
  1701. pop ax
  1702. mov cl,al
  1703.  
  1704. SHL BH, 4
  1705. OR BL, BH
  1706. MOV BH, CL
  1707.  
  1708. cmp bx,dx ; compare if bx is greater than dx if not then go to negative_sub
  1709. jge positive_sub
  1710. jl negative_sub
  1711.  
  1712. positive_sub:
  1713. clc
  1714. sbb bx,dx
  1715. jmp calc_dif
  1716.  
  1717. negative_sub:
  1718. clc
  1719. sbb dx,bx
  1720. mov bx,dx
  1721. mov si,01h
  1722. jmp calc_dif
  1723.  
  1724. calc_dif:
  1725.  
  1726. mov ah,09h
  1727. lea dx, sub_ans
  1728. int 21h
  1729.  
  1730. mov dx,0000
  1731.  
  1732. mov dh, bh ; will be used for comparison
  1733.  
  1734. and bh,0Fh ; Left over will be the hundreds
  1735. mov al,bh
  1736. call ASCII_AL
  1737. mov bh,al
  1738.  
  1739. mov dl, bl
  1740. SHR dl, 4
  1741. mov al,dl
  1742. call ASCII_AL
  1743. mov cl,al
  1744.  
  1745. and BL, 0Fh
  1746. mov al,bl
  1747. call ASCII_AL
  1748. mov bl,al
  1749.  
  1750. cmp si,01h
  1751. je neg_sign ; negative sign for negative subtractions
  1752.  
  1753. cmp dh, 0Fh
  1754. jg has_carry_sub
  1755. jle no_carry_sub
  1756.  
  1757. has_carry_sub:
  1758. mov ah,02h
  1759. mov dl,31h
  1760. int 21h
  1761. mov dl,2Eh
  1762. int 21h
  1763. mov dl,bh
  1764. int 21h
  1765. mov dl,cl
  1766. int 21h
  1767. mov dl,bl
  1768. int 21h
  1769.  
  1770. jmp sub_16_confirm
  1771.  
  1772. no_carry_sub:
  1773. mov ah,02h
  1774. mov dl,30h
  1775. int 21h
  1776. mov dl,2Eh
  1777. int 21h
  1778. mov dl,bh
  1779. int 21h
  1780. mov dl,cl
  1781. int 21h
  1782. mov dl,bl
  1783. int 21h
  1784.  
  1785. jmp sub_16_confirm
  1786.  
  1787. neg_sign:
  1788. mov si,00h
  1789. mov ah,02
  1790. mov dl,2Dh
  1791. int 21h
  1792. jmp no_carry_sub
  1793.  
  1794. ;/ Ask input to confirm if to try again.
  1795.  
  1796. sub_16_confirm:
  1797. call CENTER
  1798.  
  1799. mov ah,02h
  1800. mov dx,090Fh
  1801. int 10h
  1802. mov ah,09h
  1803. lea dx, line_2
  1804. int 21h
  1805.  
  1806. mov ah,02h
  1807. mov dx,0B20h
  1808. int 10h
  1809. mov ah,09h
  1810. lea dx, sub_again
  1811. int 21h
  1812.  
  1813. sub_16_yn_filter:
  1814. mov ah,08h
  1815. int 21h
  1816. cmp al, 'Y'
  1817. je sub_start_16
  1818. cmp al, 'y'
  1819. je sub_start_16
  1820. cmp al, 'N'
  1821. je sub_end_16
  1822. cmp al, 'n'
  1823. je sub_end_16
  1824. jmp sub_16_yn_filter
  1825.  
  1826. sub_start_16: call CAL_SUB_16
  1827. sub_end_16: call CAL_MENU_SUB
  1828.  
  1829. CAL_SUB_16 endp
  1830.  
  1831. ; Calculator Functions - Multiplication
  1832. CAL_MENU_MUL proc
  1833. call CENTER_CLEAR
  1834.  
  1835. mov ah,02h
  1836. mov dx,010Fh
  1837. int 10h
  1838. mov ah,09h
  1839. lea dx, line_1
  1840. int 21h
  1841.  
  1842. mov ah,02h
  1843. mov dx,021Eh
  1844. int 10h
  1845. mov ah,09h
  1846. lea dx, cal_header_mul
  1847. int 21h
  1848.  
  1849. mov ah,02h
  1850. mov dx,030Fh
  1851. int 10h
  1852. mov ah,09h
  1853. lea dx, line_1
  1854. int 21h
  1855.  
  1856. mov ah,02h
  1857. mov dx,0523h
  1858. int 10h
  1859. mov ah,09h
  1860. lea dx, cal_choice1
  1861. int 21h
  1862.  
  1863. mov ah,02h
  1864. mov dx,0623h
  1865. int 10h
  1866. mov ah,09h
  1867. lea dx, cal_choice2
  1868. int 21h
  1869.  
  1870. mov ah,02h
  1871. mov dx,0723h
  1872. int 10h
  1873. mov ah,09h
  1874. lea dx, cal_choice3
  1875. int 21h
  1876.  
  1877. mov ah,02h
  1878. mov dx,0823h
  1879. int 10h
  1880. mov ah,09h
  1881. lea dx, cal_choice4
  1882. int 21h
  1883.  
  1884. mov ah,02h
  1885. mov dx,0A0Fh
  1886. int 10h
  1887. mov ah,09h
  1888. lea dx, line_2
  1889. int 21h
  1890.  
  1891. mov ah,02h
  1892. mov dx,0C22h
  1893. int 10h
  1894. mov ah,09h
  1895. lea dx, m_dis10
  1896. int 21h
  1897.  
  1898. cal_mul_conf:
  1899. mov ah,08h
  1900. int 21h
  1901. cmp al,'1'
  1902. je mul_base8
  1903. cmp al, '2'
  1904. je mul_base10
  1905. cmp al, '3'
  1906. je mul_base16
  1907. cmp al, '9'
  1908. je mul_back
  1909.  
  1910. jmp cal_mul_conf
  1911.  
  1912. mul_base8: call CAL_MUL_8
  1913. mul_base10: call CAL_MUL_10
  1914. mul_base16: call CAL_MUL_16
  1915. mul_back: call CAL_MENU
  1916.  
  1917. CAL_MENU_MUL endp
  1918.  
  1919. CAL_MUL_8 proc
  1920.  
  1921. mul_start_input_8:
  1922. call CENTER_CLEAR
  1923.  
  1924. mov ah,02h
  1925. mov dx,010Fh
  1926. int 10h
  1927. mov ah,09h
  1928. lea dx, line_1
  1929. int 21h
  1930.  
  1931. mov ah,02h
  1932. mov dx,0223h
  1933. int 10h
  1934. mov ah,09h
  1935. lea dx, mul_header_base8
  1936. int 21h
  1937.  
  1938. mov ah,02h
  1939. mov dx,030Fh
  1940. int 10h
  1941. mov ah,09h
  1942. lea dx, line_1
  1943. int 21h
  1944.  
  1945. mov ah,02h
  1946. mov dx,051Dh
  1947. int 10h
  1948. mov ah,09h
  1949. lea dx, mul_input_1_8
  1950. int 21h
  1951.  
  1952. ;1st 3 Inputs
  1953. mov cl,03h
  1954. mul_8_input_1:
  1955. mov ah,01
  1956. int 21h
  1957. cmp al, '0'
  1958. jl mul_start_input_8
  1959. cmp al, '8'
  1960. jge mul_start_input_8
  1961. call DEC_AL
  1962. push ax
  1963. loop mul_8_input_1
  1964.  
  1965. mov ah,02h
  1966. mov dx,061Dh
  1967. int 10h
  1968. mov ah,09h
  1969. lea dx, mul_input_2_8
  1970. int 21h
  1971.  
  1972. ;2nd 3 Inputs
  1973. mov cl,03h
  1974. mul_8_input_2:
  1975. mov ah,01
  1976. int 21h
  1977. cmp al, '0'
  1978. jl mul_start_input_8
  1979. cmp al, '8'
  1980. jge mul_start_input_8
  1981. call DEC_AL
  1982. push ax
  1983. loop mul_8_input_2
  1984.  
  1985. mov ah,02h
  1986. mov dx,071Dh
  1987. int 10h
  1988. mov ah,09h
  1989. lea dx, mul_ans
  1990. int 21h
  1991.  
  1992. ; LOGIC FOR MUL
  1993. ;/ Ask input to confirm if to try again.
  1994.  
  1995. mul_8_confirm:
  1996. call CENTER
  1997.  
  1998. mov ah,02h
  1999. mov dx,090Fh
  2000. int 10h
  2001. mov ah,09h
  2002. lea dx, line_2
  2003. int 21h
  2004.  
  2005. mov ah,02h
  2006. mov dx,0B20h
  2007. int 10h
  2008. mov ah,09h
  2009. lea dx, mul_again
  2010. int 21h
  2011.  
  2012. mul_8_yn_filter:
  2013. mov ah,08h
  2014. int 21h
  2015. cmp al, 'Y'
  2016. je mul_start_8
  2017. cmp al, 'y'
  2018. je mul_start_8
  2019. cmp al, 'N'
  2020. je mul_end_8
  2021. cmp al, 'n'
  2022. je mul_end_8
  2023. jmp mul_8_yn_filter
  2024.  
  2025. mul_start_8: call CAL_MUL_8
  2026. mul_end_8: call CAL_MENU_MUL
  2027.  
  2028. CAL_MUL_8 endp
  2029.  
  2030. CAL_MUL_10 proc
  2031.  
  2032. mul_start_input_10:
  2033. call CENTER_CLEAR
  2034.  
  2035. mov ah,02h
  2036. mov dx,010Fh
  2037. int 10h
  2038. mov ah,09h
  2039. lea dx, line_1
  2040. int 21h
  2041.  
  2042. mov ah,02h
  2043. mov dx,0223h
  2044. int 10h
  2045. mov ah,09h
  2046. lea dx, mul_header_base10
  2047. int 21h
  2048.  
  2049. mov ah,02h
  2050. mov dx,030Fh
  2051. int 10h
  2052. mov ah,09h
  2053. lea dx, line_1
  2054. int 21h
  2055.  
  2056. mov ah,02h
  2057. mov dx,051Dh
  2058. int 10h
  2059. mov ah,09h
  2060. lea dx, mul_input_1_10
  2061. int 21h
  2062.  
  2063. ;1st 3 Inputs
  2064. mov cl,03h
  2065. mul_10_input_1:
  2066. mov ah,01
  2067. int 21h
  2068. cmp al, '0'
  2069. jl mul_start_input_10
  2070. cmp al, '9'
  2071. jg mul_start_input_10
  2072. call DEC_AL
  2073. push ax
  2074. loop mul_10_input_1
  2075.  
  2076. mov ah,02h
  2077. mov dx,061Dh
  2078. int 10h
  2079. mov ah,09h
  2080. lea dx, mul_input_2_10
  2081. int 21h
  2082.  
  2083. ;2nd 3 Inputs
  2084. mov cl,03h
  2085. mul_10_input_2:
  2086. mov ah,01
  2087. int 21h
  2088. cmp al, '0'
  2089. jl mul_start_input_10
  2090. cmp al, '9'
  2091. jg mul_start_input_10
  2092. call DEC_AL
  2093. push ax
  2094. loop mul_10_input_2
  2095.  
  2096. mov ah,02h
  2097. mov dx,071Dh
  2098. int 10h
  2099. mov ah,09h
  2100. lea dx, mul_ans
  2101. int 21h
  2102.  
  2103. ; LOGIC FOR MUL
  2104. ;/ Ask input to confirm if to try again.
  2105.  
  2106. mul_10_confirm:
  2107. call CENTER
  2108.  
  2109. mov ah,02h
  2110. mov dx,090Fh
  2111. int 10h
  2112. mov ah,09h
  2113. lea dx, line_2
  2114. int 21h
  2115.  
  2116. mov ah,02h
  2117. mov dx,0B20h
  2118. int 10h
  2119. mov ah,09h
  2120. lea dx, mul_again
  2121. int 21h
  2122.  
  2123. mul_10_yn_filter:
  2124. mov ah,08h
  2125. int 21h
  2126. cmp al, 'Y'
  2127. je mul_start_10
  2128. cmp al, 'y'
  2129. je mul_start_10
  2130. cmp al, 'N'
  2131. je mul_end_10
  2132. cmp al, 'n'
  2133. je mul_end_10
  2134. jmp mul_10_yn_filter
  2135.  
  2136. mul_start_10: call CAL_MUL_10
  2137. mul_end_10: call CAL_MENU_MUL
  2138.  
  2139. CAL_MUL_10 endp
  2140.  
  2141. CAL_MUL_16 proc
  2142.  
  2143. mul_start_input_16:
  2144. call CENTER_CLEAR
  2145.  
  2146. mov ah,02h
  2147. mov dx,010Fh
  2148. int 10h
  2149. mov ah,09h
  2150. lea dx, line_1
  2151. int 21h
  2152.  
  2153. mov ah,02h
  2154. mov dx,0223h
  2155. int 10h
  2156. mov ah,09h
  2157. lea dx, mul_header_base16
  2158. int 21h
  2159.  
  2160. mov ah,02h
  2161. mov dx,030Fh
  2162. int 10h
  2163. mov ah,09h
  2164. lea dx, line_1
  2165. int 21h
  2166.  
  2167. mov ah,02h
  2168. mov dx,051Dh
  2169. int 10h
  2170. mov ah,09h
  2171. lea dx, mul_input_1_16
  2172. int 21h
  2173.  
  2174. ;1st 3 Inputs
  2175. mov cl,03h
  2176. mul_16_input_1:
  2177. mov ah,01
  2178. int 21h
  2179. cmp al, 30h
  2180. jl mul_start_input_16
  2181. cmp al, 46h
  2182. jg mul_start_input_16
  2183. cmp al, 3ah
  2184. jb valid_mul_1
  2185. cmp al, 41h
  2186. jl mul_start_input_16
  2187. cmp al, 46h
  2188. jle valid_mul_1
  2189. valid_mul_1:
  2190. call DEC_AL
  2191. push ax
  2192. loop mul_16_input_1
  2193.  
  2194. mov ah,02h
  2195. mov dx,061Dh
  2196. int 10h
  2197. mov ah,09h
  2198. lea dx, mul_input_2_16
  2199. int 21h
  2200.  
  2201. ;2nd 3 Inputs
  2202. mov cl,03h
  2203. mul_16_input_2:
  2204. mov ah,01
  2205. int 21h
  2206. cmp al, 30h
  2207. jl mul_start_input_16
  2208. cmp al, 46h
  2209. jg mul_start_input_16
  2210. cmp al, 3ah
  2211. jb valid_mul_2
  2212. cmp al, 41h
  2213. jl mul_start_input_16
  2214. cmp al, 46h
  2215. jle valid_mul_2
  2216. valid_mul_2:
  2217. call DEC_AL
  2218. push ax
  2219. loop mul_16_input_2
  2220.  
  2221. mov ah,02h
  2222. mov dx,071Dh
  2223. int 10h
  2224. mov ah,09h
  2225. lea dx, mul_ans
  2226. int 21h
  2227.  
  2228. ; LOGIC FOR MUL
  2229. pop ax
  2230. mov bl,al
  2231. pop ax
  2232. mov bh,al
  2233. pop ax
  2234. mov cl,al
  2235.  
  2236. SHL BH, 4
  2237. OR BL, BH
  2238. MOV BH, CL
  2239.  
  2240. pop ax
  2241. mov dl,al
  2242. pop ax
  2243. mov dh,al
  2244. pop ax
  2245. mov cl,al
  2246.  
  2247. SHL DH, 4
  2248. OR DL,DH
  2249. MOV DH, CL
  2250.  
  2251. mov ax,bx ; for mul
  2252.  
  2253. mul dx
  2254. mov bx,ax ; give back to bx the final answer
  2255.  
  2256. ; final answer will be stored in DL,BX
  2257.  
  2258.  
  2259.  
  2260. ;get the value of 0.00000x
  2261.  
  2262. mov dh,bl ; back up for 0.0000x0
  2263. and bl, 0Fh ; get right most digit
  2264. mov al,bl ; to transform to ascii and push
  2265. call ASCII_AL
  2266. push ax
  2267.  
  2268. ;get the value of 0.0000x0
  2269.  
  2270. SHR dh, 4 ; move the leftmost digit to the right
  2271. and dh, 0Fh ; clear any shifted values to the left
  2272. mov al,dh
  2273. call ASCII_AL
  2274. push ax
  2275.  
  2276. ;get the value of 0.000x00
  2277.  
  2278. mov dh,bh ; back up for 0.00x000
  2279. and bh, 0Fh
  2280. mov al,bh
  2281. call ASCII_AL
  2282. push ax
  2283.  
  2284. ;get the value of 0.00x000
  2285.  
  2286. SHR dh, 4 ; move the leftmost digit to the right
  2287. and dh, 0Fh ; clear any shifted values to the left
  2288. mov al,dh
  2289. call ASCII_AL
  2290. push ax
  2291.  
  2292. ;get the value of 0.0x0000
  2293.  
  2294. mov dh,dl ; back up for 0.x00000
  2295. and dl, 0Fh
  2296. mov al, dl
  2297. call ASCII_AL
  2298. push ax
  2299.  
  2300. ;get the value of 0.x00000
  2301.  
  2302. SHR dh, 4 ; move the leftmost digit to the right
  2303. and dh, 0Fh ; clear any shifted values to the left
  2304. mov al,dh
  2305. call ASCII_AL
  2306. push ax
  2307.  
  2308. mov cl,06h
  2309. out_mul_16:
  2310.  
  2311. pop ax
  2312. mov dl,al
  2313. mov ah,02h
  2314. int 21h
  2315.  
  2316. loop out_mul_16
  2317.  
  2318. ;/ Ask input to confirm if to try again.
  2319.  
  2320. mul_16_confirm:
  2321. call CENTER
  2322.  
  2323. mov ah,02h
  2324. mov dx,090Fh
  2325. int 10h
  2326. mov ah,09h
  2327. lea dx, line_2
  2328. int 21h
  2329.  
  2330. mov ah,02h
  2331. mov dx,0B20h
  2332. int 10h
  2333. mov ah,09h
  2334. lea dx, mul_again
  2335. int 21h
  2336.  
  2337. mul_16_yn_filter:
  2338. mov ah,08h
  2339. int 21h
  2340. cmp al, 'Y'
  2341. je mul_start_16
  2342. cmp al, 'y'
  2343. je mul_start_16
  2344. cmp al, 'N'
  2345. je mul_end_16
  2346. cmp al, 'n'
  2347. je mul_end_16
  2348. jmp mul_16_yn_filter
  2349.  
  2350. mul_start_16: call CAL_MUL_16
  2351. mul_end_16: call CAL_MENU_MUL
  2352.  
  2353. CAL_MUL_16 endp
  2354.  
  2355. ; Calculator Functions - Division
  2356. CAL_MENU_DIV proc
  2357. call CENTER_CLEAR
  2358.  
  2359. mov ah,02h
  2360. mov dx,010Fh
  2361. int 10h
  2362. mov ah,09h
  2363. lea dx, line_1
  2364. int 21h
  2365.  
  2366. mov ah,02h
  2367. mov dx,021Eh
  2368. int 10h
  2369. mov ah,09h
  2370. lea dx, cal_header_div
  2371. int 21h
  2372.  
  2373. mov ah,02h
  2374. mov dx,030Fh
  2375. int 10h
  2376. mov ah,09h
  2377. lea dx, line_1
  2378. int 21h
  2379.  
  2380. mov ah,02h
  2381. mov dx,0523h
  2382. int 10h
  2383. mov ah,09h
  2384. lea dx, cal_choice1
  2385. int 21h
  2386.  
  2387. mov ah,02h
  2388. mov dx,0623h
  2389. int 10h
  2390. mov ah,09h
  2391. lea dx, cal_choice2
  2392. int 21h
  2393.  
  2394. mov ah,02h
  2395. mov dx,0723h
  2396. int 10h
  2397. mov ah,09h
  2398. lea dx, cal_choice3
  2399. int 21h
  2400.  
  2401. mov ah,02h
  2402. mov dx,0823h
  2403. int 10h
  2404. mov ah,09h
  2405. lea dx, cal_choice4
  2406. int 21h
  2407.  
  2408. mov ah,02h
  2409. mov dx,0A0Fh
  2410. int 10h
  2411. mov ah,09h
  2412. lea dx, line_2
  2413. int 21h
  2414.  
  2415. mov ah,02h
  2416. mov dx,0C22h
  2417. int 10h
  2418. mov ah,09h
  2419. lea dx, m_dis10
  2420. int 21h
  2421.  
  2422. cal_div_conf:
  2423. mov ah,08h
  2424. int 21h
  2425. cmp al,'1'
  2426. je div_base8
  2427. cmp al, '2'
  2428. je div_base10
  2429. cmp al, '3'
  2430. je div_base16
  2431. cmp al, '9'
  2432. je div_back
  2433.  
  2434. jmp cal_div_conf
  2435.  
  2436. div_base8: call CAL_DIV_8
  2437. div_base10: call CAL_DIV_10
  2438. div_base16: call CAL_DIV_16
  2439. div_back: call CAL_MENU
  2440.  
  2441. CAL_MENU_div endp
  2442.  
  2443. CAL_DIV_8 proc
  2444.  
  2445. div_start_input_8:
  2446. call CENTER_CLEAR
  2447.  
  2448. mov ah,02h
  2449. mov dx,010Fh
  2450. int 10h
  2451. mov ah,09h
  2452. lea dx, line_1
  2453. int 21h
  2454.  
  2455. mov ah,02h
  2456. mov dx,0223h
  2457. int 10h
  2458. mov ah,09h
  2459. lea dx, div_header_base8
  2460. int 21h
  2461.  
  2462. mov ah,02h
  2463. mov dx,030Fh
  2464. int 10h
  2465. mov ah,09h
  2466. lea dx, line_1
  2467. int 21h
  2468.  
  2469. mov ah,02h
  2470. mov dx,051Dh
  2471. int 10h
  2472. mov ah,09h
  2473. lea dx, div_input_1_8
  2474. int 21h
  2475.  
  2476. ;1st 3 Inputs
  2477. mov cl,03h
  2478. div_8_input_1:
  2479. mov ah,01
  2480. int 21h
  2481. cmp al, '0'
  2482. jl div_start_input_8
  2483. cmp al, '8'
  2484. jge div_start_input_8
  2485. call DEC_AL
  2486. push ax
  2487. loop div_8_input_1
  2488.  
  2489. mov ah,02h
  2490. mov dx,061Dh
  2491. int 10h
  2492. mov ah,09h
  2493. lea dx, div_input_2_8
  2494. int 21h
  2495.  
  2496. ;2nd 3 Inputs
  2497. mov cl,03h
  2498. div_8_input_2:
  2499. mov ah,01
  2500. int 21h
  2501. cmp al, '0'
  2502. jl div_start_input_8
  2503. cmp al, '8'
  2504. jge div_start_input_8
  2505. call DEC_AL
  2506. push ax
  2507. loop div_8_input_2
  2508.  
  2509. mov ah,02h
  2510. mov dx,071Dh
  2511. int 10h
  2512. mov ah,09h
  2513. lea dx, div_ans
  2514. int 21h
  2515.  
  2516. ; LOGIC FOR DIV
  2517. ;/ Ask input to confirm if to try again.
  2518.  
  2519. div_8_confirm:
  2520. call CENTER
  2521.  
  2522. mov ah,02h
  2523. mov dx,090Fh
  2524. int 10h
  2525. mov ah,09h
  2526. lea dx, line_2
  2527. int 21h
  2528.  
  2529. mov ah,02h
  2530. mov dx,0B20h
  2531. int 10h
  2532. mov ah,09h
  2533. lea dx, div_again
  2534. int 21h
  2535.  
  2536. div_8_yn_filter:
  2537. mov ah,08h
  2538. int 21h
  2539. cmp al, 'Y'
  2540. je div_start_8
  2541. cmp al, 'y'
  2542. je div_start_8
  2543. cmp al, 'N'
  2544. je div_end_8
  2545. cmp al, 'n'
  2546. je div_end_8
  2547. jmp div_8_yn_filter
  2548.  
  2549. div_start_8: call CAL_DIV_8
  2550. div_end_8: call CAL_MENU_DIV
  2551.  
  2552. CAL_DIV_8 endp
  2553.  
  2554. CAL_DIV_10 proc
  2555.  
  2556. div_start_input_10:
  2557. call CENTER_CLEAR
  2558.  
  2559. mov ah,02h
  2560. mov dx,010Fh
  2561. int 10h
  2562. mov ah,09h
  2563. lea dx, line_1
  2564. int 21h
  2565.  
  2566. mov ah,02h
  2567. mov dx,0223h
  2568. int 10h
  2569. mov ah,09h
  2570. lea dx, div_header_base10
  2571. int 21h
  2572.  
  2573. mov ah,02h
  2574. mov dx,030Fh
  2575. int 10h
  2576. mov ah,09h
  2577. lea dx, line_1
  2578. int 21h
  2579.  
  2580. mov ah,02h
  2581. mov dx,051Dh
  2582. int 10h
  2583. mov ah,09h
  2584. lea dx, div_input_1_10
  2585. int 21h
  2586.  
  2587. ;1st 3 Inputs
  2588. mov cl,03h
  2589. div_10_input_1:
  2590. mov ah,01
  2591. int 21h
  2592. cmp al, '0'
  2593. jl div_start_input_10
  2594. cmp al, '9'
  2595. jg div_start_input_10
  2596. call DEC_AL
  2597. push ax
  2598. loop div_10_input_1
  2599.  
  2600. mov ah,02h
  2601. mov dx,061Dh
  2602. int 10h
  2603. mov ah,09h
  2604. lea dx, div_input_2_10
  2605. int 21h
  2606.  
  2607. ;2nd 3 Inputs
  2608. mov cl,03h
  2609. div_10_input_2:
  2610. mov ah,01
  2611. int 21h
  2612. cmp al, '0'
  2613. jl div_start_input_10
  2614. cmp al, '9'
  2615. jg div_start_input_10
  2616. call DEC_AL
  2617. push ax
  2618. loop div_10_input_2
  2619.  
  2620. mov ah,02h
  2621. mov dx,071Dh
  2622. int 10h
  2623. mov ah,09h
  2624. lea dx, div_ans
  2625. int 21h
  2626.  
  2627. ; LOGIC FOR DIV
  2628. ;/ Ask input to confirm if to try again.
  2629.  
  2630. div_10_confirm:
  2631. call CENTER
  2632.  
  2633. mov ah,02h
  2634. mov dx,090Fh
  2635. int 10h
  2636. mov ah,09h
  2637. lea dx, line_2
  2638. int 21h
  2639.  
  2640. mov ah,02h
  2641. mov dx,0B20h
  2642. int 10h
  2643. mov ah,09h
  2644. lea dx, div_again
  2645. int 21h
  2646.  
  2647. div_10_yn_filter:
  2648. mov ah,08h
  2649. int 21h
  2650. cmp al, 'Y'
  2651. je div_start_10
  2652. cmp al, 'y'
  2653. je div_start_10
  2654. cmp al, 'N'
  2655. je div_end_10
  2656. cmp al, 'n'
  2657. je div_end_10
  2658. jmp div_10_yn_filter
  2659.  
  2660. div_start_10: call CAL_DIV_10
  2661. div_end_10: call CAL_MENU_DIV
  2662.  
  2663. CAL_DIV_10 endp
  2664.  
  2665. CAL_DIV_16 proc
  2666.  
  2667. div_start_input_16:
  2668. call CENTER_CLEAR
  2669.  
  2670. mov ah,02h
  2671. mov dx,010Fh
  2672. int 10h
  2673. mov ah,09h
  2674. lea dx, line_1
  2675. int 21h
  2676.  
  2677. mov ah,02h
  2678. mov dx,0223h
  2679. int 10h
  2680. mov ah,09h
  2681. lea dx, div_header_base16
  2682. int 21h
  2683.  
  2684. mov ah,02h
  2685. mov dx,030Fh
  2686. int 10h
  2687. mov ah,09h
  2688. lea dx, line_1
  2689. int 21h
  2690.  
  2691. mov ah,02h
  2692. mov dx,051Dh
  2693. int 10h
  2694. mov ah,09h
  2695. lea dx, div_input_1_16
  2696. int 21h
  2697.  
  2698. ;1st 3 Inputs
  2699. mov cl,03h
  2700. div_16_input_1:
  2701. mov ah,01
  2702. int 21h
  2703. cmp al, 30h
  2704. jl div_start_input_16
  2705. cmp al, 46h
  2706. jg div_start_input_16
  2707. cmp al, 3ah
  2708. jb valid_div_1
  2709. cmp al, 41h
  2710. jl div_start_input_16
  2711. cmp al, 46h
  2712. jle valid_div_1
  2713. valid_div_1:
  2714. call DEC_AL
  2715. push ax
  2716. loop div_16_input_1
  2717.  
  2718. mov ah,02h
  2719. mov dx,061Dh
  2720. int 10h
  2721. mov ah,09h
  2722. lea dx, div_input_2_16
  2723. int 21h
  2724.  
  2725. ;2nd 3 Inputs
  2726. mov cl,03h
  2727. div_16_input_2:
  2728. mov ah,01
  2729. int 21h
  2730. cmp al, 30h
  2731. jl div_start_input_16
  2732. cmp al, 46h
  2733. jg div_start_input_16
  2734. cmp al, 3ah
  2735. jb valid_div_2
  2736. cmp al, 41h
  2737. jl div_start_input_16
  2738. cmp al, 46h
  2739. jle valid_div_2
  2740. valid_div_2:
  2741. call DEC_AL
  2742. push ax
  2743. loop div_16_input_2
  2744.  
  2745. mov ah,02h
  2746. mov dx,071Dh
  2747. int 10h
  2748. mov ah,09h
  2749. lea dx, div_ans
  2750. int 21h
  2751.  
  2752. ; LOGIC FOR DIV 16
  2753. pop ax
  2754. mov bl,al
  2755. pop ax
  2756. mov bh,al
  2757. pop ax
  2758. mov cl,al
  2759.  
  2760. SHL BH, 4
  2761. OR BL, BH
  2762. MOV BH, CL
  2763.  
  2764. pop ax
  2765. mov dl,al
  2766. pop ax
  2767. mov dh,al
  2768. pop ax
  2769. mov cl,al
  2770.  
  2771. SHL DH, 4
  2772. OR DL,DH
  2773. MOV DH, CL
  2774.  
  2775. mov ax,dx ; for div
  2776. mov dx, 0000h
  2777.  
  2778. div bx
  2779. mov bx,ax ; give back to bx the final answer
  2780.  
  2781. ; final answer will be stored in DL,BX
  2782.  
  2783.  
  2784. ;get the value of 0.00x
  2785.  
  2786. mov dh,bl ; back up for 0.0000x0
  2787. and bl, 0Fh ; get right most digit
  2788. mov al,bl ; to transform to ascii and push
  2789. call ASCII_AL
  2790. push ax
  2791.  
  2792. ;get the value of 0.0x0
  2793. SHR dh, 4 ; move the the right most position
  2794. mov al,dh
  2795. call ASCII_AL
  2796. push ax
  2797.  
  2798. ;get the value of 0.x00
  2799.  
  2800. and bh,0Fh
  2801. mov al,bh
  2802. call ASCII_AL
  2803. push ax
  2804.  
  2805. mov cl,03h
  2806. out_div_16:
  2807.  
  2808. pop ax
  2809. mov dl,al
  2810. mov ah,02h
  2811. int 21h
  2812.  
  2813. loop out_div_16
  2814. div_16_confirm:
  2815.  
  2816. div_16_confirm:
  2817. call CENTER
  2818.  
  2819. mov ah,02h
  2820. mov dx,090Fh
  2821. int 10h
  2822. mov ah,09h
  2823. lea dx, line_2
  2824. int 21h
  2825.  
  2826. mov ah,02h
  2827. mov dx,0B20h
  2828. int 10h
  2829. mov ah,09h
  2830. lea dx, div_again
  2831. int 21h
  2832.  
  2833. div_16_yn_filter:
  2834. mov ah,08h
  2835. int 21h
  2836. cmp al, 'Y'
  2837. je div_start_16
  2838. cmp al, 'y'
  2839. je div_start_16
  2840. cmp al, 'N'
  2841. je div_end_16
  2842. cmp al, 'n'
  2843. je div_end_16
  2844. jmp div_16_yn_filter
  2845.  
  2846. div_start_16: call CAL_DIV_16
  2847. div_end_16: call CAL_MENU_DIV
  2848.  
  2849. CAL_DIV_16 endp
  2850.  
  2851. ; Calculator Functions - Modulo
  2852. CAL_MENU_MOD proc
  2853. call CENTER_CLEAR
  2854.  
  2855. mov ah,02h
  2856. mov dx,010Fh
  2857. int 10h
  2858. mov ah,09h
  2859. lea dx, line_1
  2860. int 21h
  2861.  
  2862. mov ah,02h
  2863. mov dx,021Eh
  2864. int 10h
  2865. mov ah,09h
  2866. lea dx, cal_header_mod
  2867. int 21h
  2868.  
  2869. mov ah,02h
  2870. mov dx,030Fh
  2871. int 10h
  2872. mov ah,09h
  2873. lea dx, line_1
  2874. int 21h
  2875.  
  2876. mov ah,02h
  2877. mov dx,0523h
  2878. int 10h
  2879. mov ah,09h
  2880. lea dx, cal_choice1
  2881. int 21h
  2882.  
  2883. mov ah,02h
  2884. mov dx,0623h
  2885. int 10h
  2886. mov ah,09h
  2887. lea dx, cal_choice2
  2888. int 21h
  2889.  
  2890. mov ah,02h
  2891. mov dx,0723h
  2892. int 10h
  2893. mov ah,09h
  2894. lea dx, cal_choice3
  2895. int 21h
  2896.  
  2897. mov ah,02h
  2898. mov dx,0823h
  2899. int 10h
  2900. mov ah,09h
  2901. lea dx, cal_choice4
  2902. int 21h
  2903.  
  2904. mov ah,02h
  2905. mov dx,0A0Fh
  2906. int 10h
  2907. mov ah,09h
  2908. lea dx, line_2
  2909. int 21h
  2910.  
  2911. mov ah,02h
  2912. mov dx,0C22h
  2913. int 10h
  2914. mov ah,09h
  2915. lea dx, m_dis10
  2916. int 21h
  2917.  
  2918. cal_mod_conf:
  2919. mov ah,08h
  2920. int 21h
  2921. cmp al,'1'
  2922. je mod_base8
  2923. cmp al, '2'
  2924. je mod_base10
  2925. cmp al, '3'
  2926. je mod_base16
  2927. cmp al, '9'
  2928. je mod_back
  2929.  
  2930. jmp cal_mod_conf
  2931.  
  2932. mod_base8: call CAL_MOD_8
  2933. mod_base10: call CAL_MOD_10
  2934. mod_base16: call CAL_MOD_16
  2935. mod_back: call CAL_MENU
  2936.  
  2937. CAL_MENU_mod endp
  2938.  
  2939. CAL_MOD_8 proc
  2940.  
  2941. mod_start_input_8:
  2942. call CENTER_CLEAR
  2943.  
  2944. mov ah,02h
  2945. mov dx,010Fh
  2946. int 10h
  2947. mov ah,09h
  2948. lea dx, line_1
  2949. int 21h
  2950.  
  2951. mov ah,02h
  2952. mov dx,0223h
  2953. int 10h
  2954. mov ah,09h
  2955. lea dx, mod_header_base8
  2956. int 21h
  2957.  
  2958. mov ah,02h
  2959. mov dx,030Fh
  2960. int 10h
  2961. mov ah,09h
  2962. lea dx, line_1
  2963. int 21h
  2964.  
  2965. mov ah,02h
  2966. mov dx,051Dh
  2967. int 10h
  2968. mov ah,09h
  2969. lea dx, mod_input_1_8
  2970. int 21h
  2971.  
  2972. ;1st 3 Inputs
  2973. mov cl,03h
  2974. mod_8_input_1:
  2975. mov ah,01
  2976. int 21h
  2977. cmp al, '0'
  2978. jl mod_start_input_8
  2979. cmp al, '8'
  2980. jge mod_start_input_8
  2981. call DEC_AL
  2982. push ax
  2983. loop mod_8_input_1
  2984.  
  2985. mov ah,02h
  2986. mov dx,061Dh
  2987. int 10h
  2988. mov ah,09h
  2989. lea dx, mod_input_2_8
  2990. int 21h
  2991.  
  2992. ;2nd 3 Inputs
  2993. mov cl,03h
  2994. mod_8_input_2:
  2995. mov ah,01
  2996. int 21h
  2997. cmp al, '0'
  2998. jl mod_start_input_8
  2999. cmp al, '8'
  3000. jge mod_start_input_8
  3001. call DEC_AL
  3002. push ax
  3003. loop mod_8_input_2
  3004.  
  3005. mov ah,02h
  3006. mov dx,071Dh
  3007. int 10h
  3008. mov ah,09h
  3009. lea dx, mod_ans
  3010. int 21h
  3011.  
  3012. ; LOGIC FOR MOD
  3013. ;/ Ask input to confirm if to try again.
  3014.  
  3015. mod_8_confirm:
  3016. call CENTER
  3017.  
  3018. mov ah,02h
  3019. mov dx,090Fh
  3020. int 10h
  3021. mov ah,09h
  3022. lea dx, line_2
  3023. int 21h
  3024.  
  3025. mov ah,02h
  3026. mov dx,0B20h
  3027. int 10h
  3028. mov ah,09h
  3029. lea dx, mod_again
  3030. int 21h
  3031.  
  3032. mod_8_yn_filter:
  3033. mov ah,08h
  3034. int 21h
  3035. cmp al, 'Y'
  3036. je mod_start_8
  3037. cmp al, 'y'
  3038. je mod_start_8
  3039. cmp al, 'N'
  3040. je mod_end_8
  3041. cmp al, 'n'
  3042. je mod_end_8
  3043. jmp mod_8_yn_filter
  3044.  
  3045. mod_start_8: call CAL_MOD_8
  3046. mod_end_8: call CAL_MENU_MOD
  3047.  
  3048. CAL_MOD_8 endp
  3049.  
  3050. CAL_MOD_10 proc
  3051.  
  3052. mod_start_input_10:
  3053. call CENTER_CLEAR
  3054.  
  3055. mov ah,02h
  3056. mov dx,010Fh
  3057. int 10h
  3058. mov ah,09h
  3059. lea dx, line_1
  3060. int 21h
  3061.  
  3062. mov ah,02h
  3063. mov dx,0223h
  3064. int 10h
  3065. mov ah,09h
  3066. lea dx, mod_header_base10
  3067. int 21h
  3068.  
  3069. mov ah,02h
  3070. mov dx,030Fh
  3071. int 10h
  3072. mov ah,09h
  3073. lea dx, line_1
  3074. int 21h
  3075.  
  3076. mov ah,02h
  3077. mov dx,051Dh
  3078. int 10h
  3079. mov ah,09h
  3080. lea dx, mod_input_1_10
  3081. int 21h
  3082.  
  3083. ;1st 3 Inputs
  3084. mov cl,03h
  3085. mod_10_input_1:
  3086. mov ah,01
  3087. int 21h
  3088. cmp al, '0'
  3089. jl mod_start_input_10
  3090. cmp al, '9'
  3091. jg mod_start_input_10
  3092. call DEC_AL
  3093. push ax
  3094. loop mod_10_input_1
  3095.  
  3096. mov ah,02h
  3097. mov dx,061Dh
  3098. int 10h
  3099. mov ah,09h
  3100. lea dx, mod_input_2_10
  3101. int 21h
  3102.  
  3103. ;2nd 3 Inputs
  3104. mov cl,03h
  3105. mod_10_input_2:
  3106. mov ah,01
  3107. int 21h
  3108. cmp al, '0'
  3109. jl mod_start_input_10
  3110. cmp al, '9'
  3111. jg mod_start_input_10
  3112. call DEC_AL
  3113. push ax
  3114. loop mod_10_input_2
  3115.  
  3116. mov ah,02h
  3117. mov dx,071Dh
  3118. int 10h
  3119. mov ah,09h
  3120. lea dx, mod_ans
  3121. int 21h
  3122.  
  3123. ; LOGIC FOR MOD
  3124. ;/ Ask input to confirm if to try again.
  3125.  
  3126. mod_10_confirm:
  3127. call CENTER
  3128.  
  3129. mov ah,02h
  3130. mov dx,090Fh
  3131. int 10h
  3132. mov ah,09h
  3133. lea dx, line_2
  3134. int 21h
  3135.  
  3136. mov ah,02h
  3137. mov dx,0B20h
  3138. int 10h
  3139. mov ah,09h
  3140. lea dx, mod_again
  3141. int 21h
  3142.  
  3143. mod_10_yn_filter:
  3144. mov ah,08h
  3145. int 21h
  3146. cmp al, 'Y'
  3147. je mod_start_10
  3148. cmp al, 'y'
  3149. je mod_start_10
  3150. cmp al, 'N'
  3151. je mod_end_10
  3152. cmp al, 'n'
  3153. je mod_end_10
  3154. jmp mod_10_yn_filter
  3155.  
  3156. mod_start_10: call CAL_MOD_10
  3157. mod_end_10: call CAL_MENU_MOD
  3158.  
  3159. CAL_MOD_10 endp
  3160.  
  3161. CAL_MOD_16 proc
  3162.  
  3163. mod_start_input_16:
  3164. call CENTER_CLEAR
  3165.  
  3166. mov ah,02h
  3167. mov dx,010Fh
  3168. int 10h
  3169. mov ah,09h
  3170. lea dx, line_1
  3171. int 21h
  3172.  
  3173. mov ah,02h
  3174. mov dx,0223h
  3175. int 10h
  3176. mov ah,09h
  3177. lea dx, mod_header_base16
  3178. int 21h
  3179.  
  3180. mov ah,02h
  3181. mov dx,030Fh
  3182. int 10h
  3183. mov ah,09h
  3184. lea dx, line_1
  3185. int 21h
  3186.  
  3187. mov ah,02h
  3188. mov dx,051Dh
  3189. int 10h
  3190. mov ah,09h
  3191. lea dx, mod_input_1_16
  3192. int 21h
  3193.  
  3194. ;1st 3 Inputs
  3195. mov cl,03h
  3196. mod_16_input_1:
  3197. mov ah,01
  3198. int 21h
  3199. cmp al, 30h
  3200. jl mod_start_input_16
  3201. cmp al, 46h
  3202. jg mod_start_input_16
  3203. cmp al, 3ah
  3204. jb valid_mod_1
  3205. cmp al, 41h
  3206. jl mod_start_input_16
  3207. cmp al, 46h
  3208. jle valid_mod_1
  3209. valid_mod_1:
  3210. call DEC_AL
  3211. push ax
  3212. loop mod_16_input_1
  3213.  
  3214. mov ah,02h
  3215. mov dx,061Dh
  3216. int 10h
  3217. mov ah,09h
  3218. lea dx, mod_input_2_16
  3219. int 21h
  3220.  
  3221. ;2nd 3 Inputs
  3222. mov cl,03h
  3223. mod_16_input_2:
  3224. mov ah,01
  3225. int 21h
  3226. cmp al, 30h
  3227. jl mod_start_input_16
  3228. cmp al, 46h
  3229. jg mod_start_input_16
  3230. cmp al, 3ah
  3231. jb valid_mod_2
  3232. cmp al, 41h
  3233. jl mod_start_input_16
  3234. cmp al, 46h
  3235. jle valid_mod_2
  3236. valid_mod_2:
  3237. call DEC_AL
  3238. push ax
  3239. loop mod_16_input_2
  3240.  
  3241. mov ah,02h
  3242. mov dx,071Dh
  3243. int 10h
  3244. mov ah,09h
  3245. lea dx, mod_ans
  3246. int 21h
  3247.  
  3248. ; LOGIC FOR MOD
  3249. pop ax
  3250. mov bl,al
  3251. pop ax
  3252. mov bh,al
  3253. pop ax
  3254. mov cl,al
  3255.  
  3256. SHL BH, 4
  3257. OR BL, BH
  3258. MOV BH, CL
  3259.  
  3260. pop ax
  3261. mov dl,al
  3262. pop ax
  3263. mov dh,al
  3264. pop ax
  3265. mov cl,al
  3266.  
  3267. SHL DH, 4
  3268. OR DL,DH
  3269. MOV DH, CL
  3270.  
  3271. mov ax,dx ; for div
  3272. mov dx, 0000h
  3273.  
  3274.  
  3275. cmp bx,ax ;compare if divisor is greater
  3276. jge out_mod_16_zero
  3277.  
  3278.  
  3279. div bx
  3280. mov bx,ax ; give back to bx the final answer
  3281.  
  3282. ; Get the remainder stored in DL 0.00x
  3283. mov cl, dl ; backup for 0.0x0
  3284. and dl, 0Fh
  3285. mov al,dl
  3286. call ASCII_AL
  3287. push ax
  3288.  
  3289. ;Get the value 0.0x0
  3290. SHR cl, 4
  3291. mov al,cl
  3292. call ASCII_AL
  3293. push ax
  3294.  
  3295. mov cl,02h
  3296. out_mod_16:
  3297.  
  3298. pop ax
  3299. mov dl,al
  3300. mov ah,02h
  3301. int 21h
  3302.  
  3303. loop out_mod_16
  3304. jmp mod_16_confirm
  3305.  
  3306. out_mod_16_zero:
  3307.  
  3308. mov ah,02h
  3309. mov dl, 30h
  3310. int 21h
  3311. int 21h
  3312.  
  3313. ;/ Ask input to confirm if to try again.
  3314.  
  3315. mod_16_confirm:
  3316. call CENTER
  3317.  
  3318. mov ah,02h
  3319. mov dx,090Fh
  3320. int 10h
  3321. mov ah,09h
  3322. lea dx, line_2
  3323. int 21h
  3324.  
  3325. mov ah,02h
  3326. mov dx,0B20h
  3327. int 10h
  3328. mov ah,09h
  3329. lea dx, mod_again
  3330. int 21h
  3331.  
  3332. mod_16_yn_filter:
  3333. mov ah,08h
  3334. int 21h
  3335. cmp al, 'Y'
  3336. je mod_start_16
  3337. cmp al, 'y'
  3338. je mod_start_16
  3339. cmp al, 'N'
  3340. je mod_end_16
  3341. cmp al, 'n'
  3342. je mod_end_16
  3343. jmp mod_16_yn_filter
  3344.  
  3345. mod_start_16: call CAL_MOD_16
  3346. mod_end_16: call CAL_MENU_MOD
  3347.  
  3348. CAL_MOD_16 endp
  3349.  
  3350. ; Conversion Functions
  3351. CON_MENU proc
  3352.  
  3353. call CENTER_CLEAR
  3354.  
  3355. mov ah,02h
  3356. mov dx,010Fh
  3357. int 10h
  3358. mov ah,09h
  3359. lea dx, line_1
  3360. int 21h
  3361.  
  3362. mov ah,02h
  3363. mov dx,0220h
  3364. int 10h
  3365. mov ah,09h
  3366. lea dx, con_menu1
  3367. int 21h
  3368.  
  3369. mov ah,02h
  3370. mov dx,030Fh
  3371. int 10h
  3372. mov ah,09h
  3373. lea dx, line_1
  3374. int 21h
  3375.  
  3376. mov ah,02h
  3377. mov dx,0520h
  3378. int 10h
  3379. mov ah,09h
  3380. lea dx, con_menu2
  3381. int 21h
  3382.  
  3383. mov ah,02h
  3384. mov dx,0620h
  3385. int 10h
  3386. mov ah,09h
  3387. lea dx, con_menu3
  3388. int 21h
  3389.  
  3390. mov ah,02h
  3391. mov dx,0720h
  3392. int 10h
  3393. mov ah,09h
  3394. lea dx, con_menu4
  3395. int 21h
  3396.  
  3397. mov ah,02h
  3398. mov dx,0820h
  3399. int 10h
  3400. mov ah,09h
  3401. lea dx, con_menu5
  3402. int 21h
  3403.  
  3404. mov ah,02h
  3405. mov dx,0920h
  3406. int 10h
  3407. mov ah,09h
  3408. lea dx, con_menu6
  3409. int 21h
  3410.  
  3411. mov ah,02h
  3412. mov dx,0A20h
  3413. int 10h
  3414. mov ah,09h
  3415. lea dx, con_menu7
  3416. int 21h
  3417.  
  3418. mov ah,02h
  3419. mov dx,0B20h
  3420. int 10h
  3421. mov ah,09h
  3422. lea dx, con_menu8
  3423. int 21h
  3424.  
  3425. mov ah,02h
  3426. mov dx,0D0Fh
  3427. int 10h
  3428. mov ah,09h
  3429. lea dx, line_2
  3430. int 21h
  3431.  
  3432. mov ah,02h
  3433. mov dx,0F20h
  3434. int 10h
  3435. mov ah,09h
  3436. lea dx, m_dis10
  3437. int 21h
  3438.  
  3439.  
  3440. con_menu_conf:
  3441. mov ah,08h
  3442. int 21h
  3443. cmp al,'1'
  3444. je go_menu_08_10
  3445. cmp al, '2'
  3446. je go_menu_08_16
  3447. cmp al, '3'
  3448. je go_menu_10_08
  3449. cmp al, '4'
  3450. je go_menu_10_16
  3451. cmp al, '5'
  3452. je go_menu_16_08
  3453. cmp al, '6'
  3454. je go_menu_16_10
  3455. cmp al, '9'
  3456. je go_menu_con
  3457. jmp con_menu_conf
  3458.  
  3459.  
  3460. go_menu_08_10: call CON_08_10
  3461. go_menu_08_16: call CON_08_16
  3462. go_menu_10_08: call CON_10_08
  3463. go_menu_10_16: call CON_10_16
  3464. go_menu_16_08: call CON_16_08
  3465. go_menu_16_10: call CON_16_10
  3466. go_menu_con: call main
  3467.  
  3468. CON_MENU endp
  3469.  
  3470. CON_08_10 proc
  3471.  
  3472. call CENTER_CLEAR
  3473.  
  3474. mov ah,02h
  3475. mov dx,010Fh
  3476. int 10h
  3477. mov ah,09h
  3478. lea dx, line_1
  3479. int 21h
  3480.  
  3481. mov ah,02h
  3482. mov dx,021Ah
  3483. int 10h
  3484. mov ah,09h
  3485. lea dx, con_header_08_10
  3486. int 21h
  3487.  
  3488. mov ah,02h
  3489. mov dx,030Fh
  3490. int 10h
  3491. mov ah,09h
  3492. lea dx, line_1
  3493. int 21h
  3494.  
  3495. mov ah,02h
  3496. mov dx,051Ah
  3497. int 10h
  3498. mov ah,09h
  3499. lea dx, con_input_08_10
  3500. int 21h
  3501.  
  3502. ;1st 3 Inputs
  3503. mov cl,03h
  3504. con_08_10_input_1:
  3505. mov ah,01
  3506. int 21h
  3507. cmp al, '0'
  3508. jl con_start_08_10
  3509. cmp al, '8'
  3510. jge con_start_08_10
  3511. call DEC_AL
  3512. push ax
  3513. loop con_08_10_input_1
  3514.  
  3515. mov ah,02h
  3516. mov dx,061Ah
  3517. int 10h
  3518. mov ah,09h
  3519. lea dx, con_ans_08_10
  3520. int 21h
  3521.  
  3522. ; LOGIC FOR CON 08 to 10
  3523. pop bx
  3524. pop cx
  3525. pop dx
  3526.  
  3527. ; Multiply first digit (input * 8^2)
  3528. mov ax,dx
  3529. and ax, 000fh
  3530. mov dx, 0040h ; 64 (8 ^ 2)
  3531. mul dx
  3532. push ax
  3533.  
  3534. ; Multiply 2nd digit (input * 8^1)
  3535. mov ax,cx
  3536. and ax, 000fh
  3537. mov cx, 0008h ; 8 (8 ^ 1)
  3538. mul cx
  3539. push ax
  3540.  
  3541. ;Multiply 3rd digit (input * 8^0)
  3542. mov ax,bx
  3543. and ax, 000fh ;clear ax
  3544. push ax
  3545.  
  3546. ; Add the values together (i*8^2) + (i*8^1) + (i*8^0)
  3547. pop ax
  3548. pop bx
  3549. pop cx
  3550.  
  3551. add bx,cx
  3552. add ax,bx
  3553.  
  3554. mov cx,0003h
  3555. CB_08_10:
  3556. sub dx,dx
  3557. mov bx,000Ah ; change to BASE
  3558. div bx
  3559. push dx
  3560. loop CB_08_10
  3561.  
  3562. mov cx,0003h
  3563. OUT_08_10:
  3564. sub ax,ax
  3565. pop ax
  3566. mov bl,al
  3567. cmp bl,0Ah
  3568. jge ASCII_08_10_NUM
  3569. or bl,30h
  3570. jmp ASCII_08_10_LET
  3571.  
  3572. ASCII_08_10_NUM:
  3573. add bl,37h
  3574.  
  3575. ASCII_08_10_LET:
  3576. mov ah,02h
  3577. mov dl,bl
  3578. int 21h
  3579.  
  3580. loop OUT_08_10
  3581.  
  3582.  
  3583. mov ah,02h
  3584. mov dx,080Fh
  3585. int 10h
  3586. mov ah,09h
  3587. lea dx, line_2
  3588. int 21h
  3589.  
  3590. mov ah,02h
  3591. mov dx,0A1Ah
  3592. int 10h
  3593. mov ah,09h
  3594. lea dx, con_again
  3595. int 21h
  3596.  
  3597.  
  3598. con_08_10_conf:
  3599. mov ah,08h
  3600. int 21h
  3601. cmp al, 'Y'
  3602. je con_start_08_10
  3603. cmp al, 'y'
  3604. je con_start_08_10
  3605. cmp al, 'N'
  3606. je con_end_08_10
  3607. cmp al, 'n'
  3608. je con_end_08_10
  3609. jmp con_08_10_conf
  3610.  
  3611. con_start_08_10: call CON_08_10
  3612. con_end_08_10: call CON_MENU
  3613. CON_08_10 endp
  3614.  
  3615. CON_08_16 proc
  3616.  
  3617. call CENTER_CLEAR
  3618.  
  3619. mov ah,02h
  3620. mov dx,010Fh
  3621. int 10h
  3622. mov ah,09h
  3623. lea dx, line_1
  3624. int 21h
  3625.  
  3626. mov ah,02h
  3627. mov dx,021Ah
  3628. int 10h
  3629. mov ah,09h
  3630. lea dx, con_header_08_16
  3631. int 21h
  3632.  
  3633. mov ah,02h
  3634. mov dx,030Fh
  3635. int 10h
  3636. mov ah,09h
  3637. lea dx, line_1
  3638. int 21h
  3639.  
  3640. mov ah,02h
  3641. mov dx,051Ah
  3642. int 10h
  3643. mov ah,09h
  3644. lea dx, con_input_08_16
  3645. int 21h
  3646.  
  3647. ;1st 3 Inputs
  3648. mov cl,03h
  3649. con_08_16_input_1:
  3650. mov ah,01
  3651. int 21h
  3652. cmp al, '0'
  3653. jl con_start_08_16
  3654. cmp al, '8'
  3655. jge con_start_08_16
  3656. call DEC_AL
  3657. push ax
  3658. loop con_08_16_input_1
  3659.  
  3660. mov ah,02h
  3661. mov dx,061Ah
  3662. int 10h
  3663. mov ah,09h
  3664. lea dx, con_ans_08_16
  3665. int 21h
  3666.  
  3667. ; LOGIC FOR CON 08 to 16
  3668. pop bx
  3669. pop cx
  3670. pop dx
  3671.  
  3672. ; Multiply first digit (input * 8^2)
  3673. mov ax,dx
  3674. and ax, 000fh
  3675. mov dx, 0040h ; 64 (16 ^ 2)
  3676. mul dx
  3677. push ax
  3678.  
  3679. ; Multiply 2nd digit (input * 8^1)
  3680. mov ax,cx
  3681. and ax, 000fh
  3682. mov cx, 0008h ; 8 (16 ^ 1)
  3683. mul cx
  3684. push ax
  3685.  
  3686. ;Multiply 3rd digit (input * 8^0)
  3687. mov ax,bx
  3688. and ax, 000fh ;clear ax
  3689. push ax
  3690.  
  3691. ; Add the values together (i*8^2) + (i*8^1) + (i*8^0)
  3692. pop ax
  3693. pop bx
  3694. pop cx
  3695.  
  3696. add bx,cx
  3697. add ax,bx
  3698.  
  3699. mov cx,0003h
  3700. CB_08_16:
  3701. sub dx,dx
  3702. mov bx,0010h ; change to BASE / 08 to (16d)/(10h)
  3703. div bx
  3704. push dx
  3705. loop CB_08_16
  3706.  
  3707. mov cx,0003h
  3708. OUT_08_16:
  3709. sub ax,ax
  3710. pop ax
  3711. mov bl,al
  3712. cmp bl,0Ah
  3713. jge ASCII_08_16_NUM
  3714. or bl,30h
  3715. jmp ASCII_08_16_LET
  3716.  
  3717. ASCII_08_16_NUM:
  3718. add bl,37h
  3719.  
  3720. ASCII_08_16_LET:
  3721. mov ah,02h
  3722. mov dl,bl
  3723. int 21h
  3724.  
  3725. loop OUT_08_16
  3726.  
  3727. mov ah,02h
  3728. mov dx,080Fh
  3729. int 10h
  3730. mov ah,09h
  3731. lea dx, line_2
  3732. int 21h
  3733.  
  3734. mov ah,02h
  3735. mov dx,0A1Ah
  3736. int 10h
  3737. mov ah,09h
  3738. lea dx, con_again
  3739. int 21h
  3740.  
  3741.  
  3742. con_08_16_conf:
  3743. mov ah,08h
  3744. int 21h
  3745. cmp al, 'Y'
  3746. je con_start_08_16
  3747. cmp al, 'y'
  3748. je con_start_08_16
  3749. cmp al, 'N'
  3750. je con_end_08_16
  3751. cmp al, 'n'
  3752. je con_end_08_16
  3753. jmp con_08_16_conf
  3754.  
  3755. con_start_08_16: call CON_08_16
  3756. con_end_08_16: call CON_MENU
  3757. CON_08_16 endp
  3758.  
  3759. CON_10_08 proc
  3760.  
  3761. call CENTER_CLEAR
  3762.  
  3763. mov ah,02h
  3764. mov dx,010Fh
  3765. int 10h
  3766. mov ah,09h
  3767. lea dx, line_1
  3768. int 21h
  3769.  
  3770. mov ah,02h
  3771. mov dx,021Ah
  3772. int 10h
  3773. mov ah,09h
  3774. lea dx, con_header_10_08
  3775. int 21h
  3776.  
  3777. mov ah,02h
  3778. mov dx,030Fh
  3779. int 10h
  3780. mov ah,09h
  3781. lea dx, line_1
  3782. int 21h
  3783.  
  3784. mov ah,02h
  3785. mov dx,051Ah
  3786. int 10h
  3787. mov ah,09h
  3788. lea dx, con_input_10_08
  3789. int 21h
  3790.  
  3791. ;1st 3 Inputs
  3792. mov cl,03h
  3793. con_10_08_input_1:
  3794. mov ah,01
  3795. int 21h
  3796. cmp al, '0'
  3797. jl con_start_10_08
  3798. cmp al, '9'
  3799. jg con_start_10_08
  3800. call DEC_AL
  3801. push ax
  3802. loop con_10_08_input_1
  3803.  
  3804. mov ah,02h
  3805. mov dx,061Ah
  3806. int 10h
  3807. mov ah,09h
  3808. lea dx, con_ans_10_08
  3809. int 21h
  3810.  
  3811. ; LOGIC FOR CON 10 to 08
  3812. pop bx
  3813. pop cx
  3814. pop dx
  3815.  
  3816. ; Multiply first digit (input * 8^2)
  3817. mov ax,dx
  3818. and ax, 000fh
  3819. mov dx, 0064h ; 100 (10 ^ 2)
  3820. mul dx
  3821. push ax
  3822.  
  3823. ; Multiply 2nd digit (input * 8^1)
  3824. mov ax,cx
  3825. and ax, 000fh
  3826. mov cx, 000Ah ; 10 (10 ^ 1)
  3827. mul cx
  3828. push ax
  3829.  
  3830. ;Multiply 3rd digit (input * 8^0)
  3831. mov ax,bx
  3832. and ax, 000fh ;clear ax
  3833. push ax
  3834.  
  3835. ; Add the values together (i*8^2) + (i*8^1) + (i*8^0)
  3836. pop ax
  3837. pop bx
  3838. pop cx
  3839.  
  3840. add bx,cx
  3841. add ax,bx
  3842.  
  3843. mov cx,0004h
  3844. CB_10_16:
  3845. sub dx,dx
  3846. mov bx,0010h ; change to BASE 16
  3847. div bx
  3848. push dx
  3849. loop CB_10_16
  3850.  
  3851. mov cx,0004h
  3852. OUT_10_16:
  3853. sub ax,ax
  3854. pop ax
  3855. mov bl,al
  3856. cmp bl,0Ah
  3857. jge ASCII_10_16_NUM
  3858. or bl,30h
  3859. jmp ASCII_10_16_LET
  3860.  
  3861. ASCII_10_16_NUM:
  3862. add bl,37h
  3863.  
  3864. ASCII_10_16_LET:
  3865. mov ah,02h
  3866. mov dl,bl
  3867. int 21h
  3868.  
  3869. loop OUT_10_16
  3870.  
  3871. mov ah,02h
  3872. mov dx,080Fh
  3873. int 10h
  3874. mov ah,09h
  3875. lea dx, line_2
  3876. int 21h
  3877.  
  3878. mov ah,02h
  3879. mov dx,0A1Ah
  3880. int 10h
  3881. mov ah,09h
  3882. lea dx, con_again
  3883. int 21h
  3884.  
  3885.  
  3886. con_10_08_conf:
  3887. mov ah,08h
  3888. int 21h
  3889. cmp al, 'Y'
  3890. je con_start_10_08
  3891. cmp al, 'y'
  3892. je con_start_10_08
  3893. cmp al, 'N'
  3894. je con_end_10_08
  3895. cmp al, 'n'
  3896. je con_end_10_08
  3897. jmp con_10_08_conf
  3898.  
  3899. con_start_10_08: call CON_10_08
  3900. con_end_10_08: call CON_MENU
  3901.  
  3902. CON_10_08 endp
  3903.  
  3904. CON_10_16 proc
  3905.  
  3906. call CENTER_CLEAR
  3907.  
  3908. mov ah,02h
  3909. mov dx,010Fh
  3910. int 10h
  3911. mov ah,09h
  3912. lea dx, line_1
  3913. int 21h
  3914.  
  3915. mov ah,02h
  3916. mov dx,021Ah
  3917. int 10h
  3918. mov ah,09h
  3919. lea dx, con_header_10_16
  3920. int 21h
  3921.  
  3922. mov ah,02h
  3923. mov dx,030Fh
  3924. int 10h
  3925. mov ah,09h
  3926. lea dx, line_1
  3927. int 21h
  3928.  
  3929. mov ah,02h
  3930. mov dx,051Ah
  3931. int 10h
  3932. mov ah,09h
  3933. lea dx, con_input_10_16
  3934. int 21h
  3935.  
  3936. ;1st 3 Inputs
  3937. mov cl,03h
  3938. con_10_16_input_1:
  3939. mov ah,01
  3940. int 21h
  3941. cmp al, '0'
  3942. jl con_start_10_16
  3943. cmp al, '9'
  3944. jg con_start_10_16
  3945. call DEC_AL
  3946. push ax
  3947. loop con_10_16_input_1
  3948.  
  3949. mov ah,02h
  3950. mov dx,061Ah
  3951. int 10h
  3952. mov ah,09h
  3953. lea dx, con_ans_10_16
  3954. int 21h
  3955.  
  3956. ; LOGIC FOR CON 10 to 08
  3957. pop bx
  3958. pop cx
  3959. pop dx
  3960.  
  3961. ; Multiply first digit (input * 8^2)
  3962. mov ax,dx
  3963. and ax, 000fh
  3964. mov dx, 0064h ; 100 (10 ^ 2)
  3965. mul dx
  3966. push ax
  3967.  
  3968. ; Multiply 2nd digit (input * 8^1)
  3969. mov ax,cx
  3970. and ax, 000fh
  3971. mov cx, 000Ah ; 10 (10 ^ 1)
  3972. mul cx
  3973. push ax
  3974.  
  3975. ;Multiply 3rd digit (input * 8^0)
  3976. mov ax,bx
  3977. and ax, 000fh ;clear ax
  3978. push ax
  3979.  
  3980. ; Add the values together (i*8^2) + (i*8^1) + (i*8^0)
  3981. pop ax
  3982. pop bx
  3983. pop cx
  3984.  
  3985. add bx,cx
  3986. add ax,bx
  3987.  
  3988. mov cx,0003h
  3989. CB_10_16_x:
  3990. sub dx,dx
  3991. mov bx,0010h ; change to BASE 8
  3992. div bx
  3993. push dx
  3994. loop CB_10_16_x
  3995.  
  3996. mov cx,0003h
  3997. OUT_10_16_x:
  3998. sub ax,ax
  3999. pop ax
  4000. mov bl,al
  4001. cmp bl,0Ah
  4002. jge ASCII_10_16_NUM
  4003. or bl,30h
  4004. jmp ASCII_10_16_LET
  4005.  
  4006. ASCII_10_16_NUM_x:
  4007. add bl,37h
  4008.  
  4009. ASCII_10_16_LET_x:
  4010. mov ah,02h
  4011. mov dl,bl
  4012. int 21h
  4013.  
  4014. loop OUT_10_16_x
  4015.  
  4016. mov ah,02h
  4017. mov dx,080Fh
  4018. int 10h
  4019. mov ah,09h
  4020. lea dx, line_2
  4021. int 21h
  4022.  
  4023. mov ah,02h
  4024. mov dx,0A1Ah
  4025. int 10h
  4026. mov ah,09h
  4027. lea dx, con_again
  4028. int 21h
  4029.  
  4030.  
  4031. con_10_16_conf:
  4032. mov ah,08h
  4033. int 21h
  4034. cmp al, 'Y'
  4035. je con_start_10_16
  4036. cmp al, 'y'
  4037. je con_start_10_16
  4038. cmp al, 'N'
  4039. je con_end_10_16
  4040. cmp al, 'n'
  4041. je con_end_10_16
  4042. jmp con_10_16_conf
  4043.  
  4044. con_start_10_16: call CON_10_16
  4045. con_end_10_16: call CON_MENU
  4046.  
  4047. CON_10_16 endp
  4048.  
  4049. CON_16_08 proc
  4050. con_start_input_16:
  4051. call CENTER_CLEAR
  4052.  
  4053. mov ah,02h
  4054. mov dx,010Fh
  4055. int 10h
  4056. mov ah,09h
  4057. lea dx, line_1
  4058. int 21h
  4059.  
  4060. mov ah,02h
  4061. mov dx,021Ah
  4062. int 10h
  4063. mov ah,09h
  4064. lea dx, con_header_16_08
  4065. int 21h
  4066.  
  4067. mov ah,02h
  4068. mov dx,030Fh
  4069. int 10h
  4070. mov ah,09h
  4071. lea dx, line_1
  4072. int 21h
  4073.  
  4074. mov ah,02h
  4075. mov dx,051Ah
  4076. int 10h
  4077. mov ah,09h
  4078. lea dx, con_input_16_08
  4079. int 21h
  4080.  
  4081. ;1st 3 Inputs
  4082. mov cl,03h
  4083. con_16_input_1:
  4084. mov ah,01
  4085. int 21h
  4086. cmp al, 30h
  4087. jl con_start_input_16
  4088. cmp al, 46h
  4089. jg con_start_input_16
  4090. cmp al, 3ah
  4091. jb valid_con_1
  4092. cmp al, 41h
  4093. jl con_start_input_16
  4094. cmp al, 46h
  4095. jle valid_con_1
  4096. valid_con_1:
  4097. call DEC_AL
  4098. push ax
  4099. loop con_16_input_1
  4100.  
  4101. mov ah,02h
  4102. mov dx,061Ah
  4103. int 10h
  4104. mov ah,09h
  4105. lea dx, con_ans_16_08
  4106. int 21h
  4107.  
  4108. ; LOGIC FOR CON 16 to 08
  4109. pop bx
  4110. pop cx
  4111. pop dx
  4112.  
  4113. ; Multiply first digit (input * 16^2)
  4114. mov ax,dx
  4115. and ax, 000fh
  4116. mov dx, 0100h ; 256 (16 ^ 2)
  4117. mul dx
  4118. push ax
  4119.  
  4120. ; Multiply 2nd digit (input * 8^1)
  4121. mov ax,cx
  4122. and ax, 000fh
  4123. mov cx, 0010h ; 16 (16 ^ 1)
  4124. mul cx
  4125. push ax
  4126.  
  4127. ;Multiply 3rd digit (input * 16^0)
  4128. mov ax,bx
  4129. and ax, 000Fh ;clear ax
  4130. push ax
  4131.  
  4132. ; Add the values together (i*16^2) + (i*16^1) + (i*16^0)
  4133. pop ax
  4134. pop bx
  4135. pop cx
  4136.  
  4137. add bx,cx
  4138. add ax,bx
  4139.  
  4140. mov cx,0004h
  4141. CB_16_08:
  4142. sub dx,dx
  4143. mov bx,0008h ; change to BASE
  4144. div bx
  4145. push dx
  4146. loop CB_16_08
  4147.  
  4148. mov cx,0004h
  4149. OUT_16_08:
  4150. sub ax,ax
  4151. pop ax
  4152. mov bl,al
  4153. cmp bl,0Ah
  4154. jge ASCII_16_08_NUM
  4155. or bl,30h
  4156. jmp ASCII_16_08_LET
  4157.  
  4158. ASCII_16_08_NUM:
  4159. add bl,37h
  4160.  
  4161. ASCII_16_08_LET:
  4162. mov ah,02h
  4163. mov dl,bl
  4164. int 21h
  4165.  
  4166. loop OUT_16_08
  4167.  
  4168.  
  4169. mov ah,02h
  4170. mov dx,080Fh
  4171. int 10h
  4172. mov ah,09h
  4173. lea dx, line_2
  4174. int 21h
  4175.  
  4176. mov ah,02h
  4177. mov dx,0A1Ah
  4178. int 10h
  4179. mov ah,09h
  4180. lea dx, con_again
  4181. int 21h
  4182.  
  4183.  
  4184. con_16_08_conf:
  4185. mov ah,08h
  4186. int 21h
  4187. cmp al, 'Y'
  4188. je con_start_16_08
  4189. cmp al, 'y'
  4190. je con_start_16_08
  4191. cmp al, 'N'
  4192. je con_end_16_08
  4193. cmp al, 'n'
  4194. je con_end_16_08
  4195. jmp con_16_08_conf
  4196.  
  4197. con_start_16_08: call CON_16_08
  4198. con_end_16_08: call CON_MENU
  4199.  
  4200. CON_16_08 endp
  4201.  
  4202. CON_16_10 proc
  4203. con_start_input_16_2:
  4204. call CENTER_CLEAR
  4205.  
  4206. mov ah,02h
  4207. mov dx,010Fh
  4208. int 10h
  4209. mov ah,09h
  4210. lea dx, line_1
  4211. int 21h
  4212.  
  4213. mov ah,02h
  4214. mov dx,021Ah
  4215. int 10h
  4216. mov ah,09h
  4217. lea dx, con_header_16_10
  4218. int 21h
  4219.  
  4220. mov ah,02h
  4221. mov dx,030Fh
  4222. int 10h
  4223. mov ah,09h
  4224. lea dx, line_1
  4225. int 21h
  4226.  
  4227. mov ah,02h
  4228. mov dx,051Ah
  4229. int 10h
  4230. mov ah,09h
  4231. lea dx, con_input_16_10
  4232. int 21h
  4233.  
  4234. ;1st 3 Inputs
  4235. mov cl,03h
  4236. con_16_input_2:
  4237. mov ah,01
  4238. int 21h
  4239. cmp al, 30h
  4240. jl con_start_input_16_2
  4241. cmp al, 46h
  4242. jg con_start_input_16_2
  4243. cmp al, 3ah
  4244. jb valid_con_2
  4245. cmp al, 41h
  4246. jl con_start_input_16_2
  4247. cmp al, 46h
  4248. jle valid_con_2
  4249. valid_con_2:
  4250. call DEC_AL
  4251. push ax
  4252. loop con_16_input_2
  4253.  
  4254. mov ah,02h
  4255. mov dx,061Ah
  4256. int 10h
  4257. mov ah,09h
  4258. lea dx, con_ans_16_10
  4259. int 21h
  4260.  
  4261. ; LOGIC FOR CON 16 to 10
  4262. pop bx
  4263. pop cx
  4264. pop dx
  4265.  
  4266. ; Multiply first digit (input * 16^2)
  4267. mov ax,dx
  4268. and ax, 000fh
  4269. mov dx, 0100h ; 256 (16 ^ 2)
  4270. mul dx
  4271. push ax
  4272.  
  4273. ; Multiply 2nd digit (input * 8^1)
  4274. mov ax,cx
  4275. and ax, 000fh
  4276. mov cx, 0010h ; 16 (16 ^ 1)
  4277. mul cx
  4278. push ax
  4279.  
  4280. ;Multiply 3rd digit (input * 16^0)
  4281. mov ax,bx
  4282. and ax, 000Fh ;clear ax
  4283. push ax
  4284.  
  4285. ; Add the values together (i*16^2) + (i*16^1) + (i*16^0)
  4286. pop ax
  4287. pop bx
  4288. pop cx
  4289.  
  4290. add bx,cx
  4291. add ax,bx
  4292.  
  4293. mov cx,0004h
  4294. CB_16_10:
  4295. sub dx,dx
  4296. mov bx,000Ah ; change to BASE
  4297. div bx
  4298. push dx
  4299. loop CB_16_10
  4300.  
  4301. mov cx,0004h
  4302. OUT_16_10:
  4303. sub ax,ax
  4304. pop ax
  4305. mov bl,al
  4306. cmp bl,0Ah
  4307. jge ASCII_16_10_NUM
  4308. or bl,30h
  4309. jmp ASCII_16_10_LET
  4310.  
  4311. ASCII_16_10_NUM:
  4312. add bl,37h
  4313.  
  4314. ASCII_16_10_LET:
  4315. mov ah,02h
  4316. mov dl,bl
  4317. int 21h
  4318.  
  4319. loop OUT_16_10
  4320.  
  4321. mov ah,02h
  4322. mov dx,080Fh
  4323. int 10h
  4324. mov ah,09h
  4325. lea dx, line_2
  4326. int 21h
  4327.  
  4328. mov ah,02h
  4329. mov dx,0A1Ah
  4330. int 10h
  4331. mov ah,09h
  4332. lea dx, con_again
  4333. int 21h
  4334.  
  4335.  
  4336. con_16_10_conf:
  4337. mov ah,08h
  4338. int 21h
  4339. cmp al, 'Y'
  4340. je con_start_16_10
  4341. cmp al, 'y'
  4342. je con_start_16_10
  4343. cmp al, 'N'
  4344. je con_end_16_10
  4345. cmp al, 'n'
  4346. je con_end_16_10
  4347. jmp con_16_10_conf
  4348.  
  4349. con_start_16_10: call CON_16_10
  4350. con_end_16_10: call CON_MENU
  4351.  
  4352. CON_16_10 endp
  4353.  
  4354. ; Input Functions
  4355. GET_INPUT PROC
  4356. mov cl, 3h
  4357.  
  4358. loop_input:
  4359. mov ah,01h
  4360. int 21h
  4361. call DEC_AL
  4362. push ax
  4363. loop loop_input
  4364.  
  4365. ret
  4366. GET_INPUT ENDP
  4367. ; Turns ASCII Hex input to their decimal counterpart.
  4368. DEC_AL PROC
  4369. mov ah,al
  4370. cmp ah, 41h ; A in ASCII
  4371. jge is_let ; AL - 31H to get the decimal equivalent of the letter
  4372. jl is_num ; AL - 30H to get the decimal equivalent of the number
  4373.  
  4374. is_num:
  4375. sub ah,30h
  4376. jmp return
  4377. is_let:
  4378. sub ah, 37h
  4379. jmp return
  4380.  
  4381. return:
  4382. mov al,ah
  4383. mov ah,01
  4384. ret
  4385. DEC_AL ENDP
  4386. ; Turns Hex Input to their ASCII counterpart
  4387. ASCII_AL PROC
  4388. mov ah,al
  4389. cmp ah, 0Ah ; A in ASCII
  4390. jge is_let_ascii ; AL - 31H to get the decimal equivalent of the letter
  4391. jl is_num_ascii ; AL - 30H to get the decimal equivalent of the number
  4392.  
  4393. is_num_ascii:
  4394. add ah,30h
  4395. jmp return_ascii
  4396. is_let_ascii:
  4397. add ah, 37h
  4398. jmp return_ascii
  4399.  
  4400. return_ascii:
  4401. mov al,ah
  4402. mov ah,01
  4403. ret
  4404. ASCII_AL ENDP
  4405.  
  4406. ; Universal Functions
  4407. TERMINATE proc
  4408.  
  4409. call CENTER_CLEAR
  4410. mov ah,02h
  4411. mov dx,010Fh
  4412. int 10h
  4413. mov ah,09h
  4414. lea dx, line_1
  4415. int 21h
  4416.  
  4417. mov ah,02h
  4418. mov dx,0218h
  4419. int 10h
  4420. mov ah,09h
  4421. lea dx, exit_dis2
  4422. int 21h
  4423.  
  4424. mov ah,02h
  4425. mov dx,030Fh
  4426. int 10h
  4427. mov ah,09h
  4428. lea dx, line_1
  4429. int 21h
  4430.  
  4431. mov ah,02h
  4432. mov dx,040Fh
  4433. int 10h
  4434. mov ah,09h
  4435. lea dx, line_2
  4436. int 21h
  4437.  
  4438. mov ah,02h
  4439. mov dx,051Ah
  4440. int 10h
  4441. mov ah,09h
  4442. lea dx, exit_dis1
  4443. int 21h
  4444.  
  4445. mov ah,02h
  4446. mov dx,060Fh
  4447. int 10h
  4448. mov ah,09h
  4449. lea dx, line_2
  4450. int 21h
  4451.  
  4452. mov ah,02h
  4453. mov dx,070Fh
  4454. int 10h
  4455. mov ah,09h
  4456. lea dx, line_1
  4457. int 21h
  4458.  
  4459. mov ah,02h
  4460. mov dx,0A23h
  4461. int 10h
  4462. mov ah,09h
  4463. lea dx, exit_dis3
  4464. int 21h
  4465.  
  4466. mov ah,02h
  4467. mov dx,0C1Dh
  4468. int 10h
  4469. mov ah,09h
  4470. lea dx, exit_dis4
  4471. int 21h
  4472.  
  4473. mov ah,02h
  4474. mov dx,0D20h
  4475. int 10h
  4476. mov ah,09h
  4477. lea dx, exit_dis5
  4478. int 21h
  4479.  
  4480. mov ah,02h
  4481. mov dx,110Fh
  4482. int 10h
  4483. mov ah,09h
  4484. lea dx, line_1
  4485. int 21h
  4486.  
  4487. mov ah,4ch
  4488. int 21h
  4489. TERMINATE endp
  4490. CENTER proc
  4491. mov ax, 0000h
  4492. mov bx, 0000h
  4493. mov cx, 0000h
  4494. mov dx, 0000h
  4495. ret
  4496. CENTER endp
  4497. CENTER_CLEAR proc
  4498. mov ax,0600h
  4499. mov bh,0Dh
  4500. mov cx,0000h
  4501. mov dx,184Fh
  4502. int 10h
  4503. mov bh,00h
  4504. ret
  4505. CENTER_CLEAR endp
  4506. BACKSPACE proc
  4507. mov ah, 01h ; read a character from standard input
  4508. int 21h
  4509.  
  4510. mov dl, 08h ; move the cursor back one position
  4511. mov ah, 02h
  4512. int 21h
  4513.  
  4514. mov dl, ' ' ; overwrite the character with a space
  4515. mov ah, 02h
  4516. int 21h
  4517.  
  4518. mov dl, 08h ; move the cursor back again
  4519. mov ah, 02h
  4520. int 21h
  4521. ret
  4522. BACKSPACE endp
  4523.  
  4524. ; Convert Functions
  4525. CONVERT_08_16 proc
  4526. ; LOGIC FOR CON 08 to 16
  4527. pop bx
  4528. pop cx
  4529. pop dx
  4530.  
  4531. ; Multiply first digit (input * 8^2)
  4532. mov ax,dx
  4533. and ax, 000fh
  4534. mov dx, 0040h ; 64 (16 ^ 2)
  4535. mul dx
  4536. push ax
  4537.  
  4538. ; Multiply 2nd digit (input * 8^1)
  4539. mov ax,cx
  4540. and ax, 000fh
  4541. mov cx, 0008h ; 8 (16 ^ 1)
  4542. mul cx
  4543. push ax
  4544.  
  4545. ;Multiply 3rd digit (input * 8^0)
  4546. mov ax,bx
  4547. and ax, 000fh ;clear ax
  4548. push ax
  4549.  
  4550. ; Add the values together (i*8^2) + (i*8^1) + (i*8^0)
  4551. pop ax
  4552. pop bx
  4553. pop cx
  4554.  
  4555. add bx,cx
  4556. add ax,bx
  4557.  
  4558. mov cx,0003h
  4559. COB_08_16:
  4560. sub dx,dx
  4561. mov bx,0010h ; change to BASE / 08 to (16d)/(10h)
  4562. div bx
  4563. push dx
  4564. loop COB_08_16
  4565.  
  4566. CONVERT_08_16 endp
  4567.  
  4568. CONVERT_16_08 proc
  4569. CONVERT_16_08 endp
  4570.  
  4571. CONVERT_10_16 proc
  4572. CONVERT_10_16 endp
  4573.  
  4574. CONVERT_16_10 proc
  4575. CONVERT_16_10 endp
  4576.  
  4577.  
  4578. end main
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!