home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / MASM.ZIP / SAMPLES / INCLUDE / DOS.IN$ / DOS.bin
Encoding:
Text File  |  1991-02-28  |  10.6 KB  |  522 lines

  1. ; DOS Interface Macros - Version 1.2 - for Microsoft Macro Assembler 6.0
  2. ; (C) Copyright Microsoft Corporation, 1987, 1988, 1989, 1990
  3.  
  4. ; Typedefs for testing pointers
  5. NPVOID  TYPEDEF NEAR PTR
  6. FPVOID  TYPEDEF FAR  PTR
  7.  
  8. ; Internal
  9. __LdAdr MACRO reg:REQ, adr:REQ
  10.     IF (OPATTR (adr)) AND 00010000y
  11.         mov     reg, adr               ;; Register
  12.     ELSEIF (OPATTR (adr)) AND 00000100y
  13.         mov     reg, adr               ;; Constant
  14.     ELSEIF (TYPE (adr) EQ BYTE)  OR (TYPE (adr) EQ SBYTE)
  15.         mov    reg, OFFSET adr         ;; Bytes
  16.     ELSEIF (TYPE (adr) EQ NPVOID) OR (TYPE (adr) EQ WORD)
  17.         mov    reg, adr                ;; Near pointer
  18.     ELSEIF (TYPE (adr) EQ FPVOID) OR (TYPE (adr) EQ DWORD)
  19.         mov    reg, WORD PTR adr[0]    ;; Far pointer
  20.         mov    ds,  WORD PTR adr[2]
  21.     ELSE
  22.         .ERR <Illegal argument>
  23.     ENDIF
  24. ENDM
  25.  
  26.  
  27. ; Internal
  28. __LdSeg MACRO dest:REQ, src:REQ
  29.     IFIDNI <src>, <es>                 ;; Segment register
  30.         mov     ax, src
  31.         mov     dest, ax
  32.     ELSEIFIDNI <src>, <ss>
  33.         mov     ax, src
  34.         mov     dest, ax
  35.     ELSEIFIDNI <src>, <ds>
  36.         mov     ax, src
  37.         mov     dest, ax
  38.     ELSEIFIDNI <src>, <cs>
  39.         mov     ax, src
  40.         mov     dest, ax
  41.     ELSEIF (OPATTR (src)) AND 00000100y ;; Constant
  42.         mov     ax, src
  43.         mov     dest, ax
  44.     ELSE                                ;; Memory or general register
  45.         mov     dest, src
  46.     ENDIF
  47. ENDM
  48.  
  49. ; Internal
  50. __LdDub MACRO dub:REQ
  51.     IF ((OPATTR (dub)) AND 00000100y)
  52.         IF ((dub) LE 0FFFFh)
  53.              sub  cx, cx
  54.              mov  dx, dub
  55.         ELSE
  56.              sub  cx, HIGWORD dub
  57.              mov  dx, LOWWORD dub
  58.         ENDIF
  59.     ELSEIF   TYPE (dub) EQ 2
  60.         sub  cx, cx
  61.         mov  dx, dub
  62.     ELSEIF TYPE (dub) EQ 4
  63.         mov  cx, dub[2]
  64.         mov  dx, dub[0]
  65.     ELSEIF TYPE (dub) EQ 0
  66.         sub     cx, cx
  67.         mov     dx, dub
  68.     ELSE
  69.         .ERR
  70.         ECHO Illegal argument
  71.     ENDIF
  72. ENDM
  73.  
  74. ; 01h, 07h, 08h, 0Ch
  75. @GetChar MACRO ech:=<1>, cc:=<1>, clear:=<0>
  76.     LOCAL   funct, disp
  77.     disp    = 1
  78.     IF  ech
  79.         IF  cc
  80.             funct   = 01h       ;; Echo with break checking
  81.         ELSE
  82.             funct   = 07h       ;; Echo without break checking
  83.             disp    = 02h       ;; Need separate call to echo
  84.         ENDIF
  85.     ELSE
  86.         IF  cc
  87.             funct   = 08h       ;; No echo with break checking
  88.         ELSE
  89.             funct   = 07h       ;; No echo without break checking
  90.         ENDIF
  91.     ENDIF
  92.     IFE clear
  93.         mov     ah, funct       ;; Load function directly
  94.     ELSE
  95.         mov     ah, 0Ch         ;; If clear set, call function
  96.         mov     al, funct       ;;  indirectly with function 0Ch
  97.     ENDIF
  98.     int     21h                 ;; Call DOS
  99.     IF disp EQ 02h              ;; Separate call for echo without
  100.         mov     dl, al          ;;  break checking
  101.         mov     ah, disp
  102.         int     21h
  103.     ENDIF
  104. ENDM
  105.  
  106. ; 0Ah
  107. @GetStr MACRO ofset:REQ, terminator, limit, segmnt
  108.     __LdAdr dx, <ofset>
  109.     IFNB    <segmnt>
  110.         __LdSeg ds, <segmnt>
  111.     ENDIF
  112.     mov     ah, 0Ah
  113.     mov     si, dx
  114.     IFNB    <limit>
  115.         mov     BYTE PTR [si], limit
  116.     ENDIF
  117.     int     21h
  118.     inc     si
  119.     mov     bl, [si]
  120.     sub     bh, bh
  121.     inc     si
  122.     IFNB    <terminator>
  123.         mov     BYTE PTR [bx+si], terminator
  124.     ENDIF
  125. ENDM
  126.  
  127. ; 02h
  128. @ShowChar MACRO chr:VARARG
  129.     mov     ah, 02h
  130.     FOR arg, <chr>
  131.         IFDIFI  <arg>, <dl>
  132.             mov     dl, arg
  133.         ENDIF
  134.         int     21h
  135.     ENDM
  136. ENDM
  137.  
  138. ; 05h
  139. @PrtChar MACRO chr:VARARG
  140.     mov     ah, 05h
  141.     FOR arg, <chr>
  142.         IFDIFI  <arg>, <dl>
  143.             mov     dl, arg
  144.         ENDIF
  145.         int     21h
  146.     ENDM
  147. ENDM
  148.  
  149. ; 09h
  150. @ShowStr MACRO ofset:REQ, segmnt
  151.     LOCAL  msg, sseg
  152.     IF @InStr( 1, ofset, <!"> ) EQ 1
  153.         sseg    TEXTEQU @CurSeg
  154.         .DATA
  155.         msg     BYTE    ofset, "$"
  156.         sseg    SEGMENT
  157.         mov     dx, OFFSET msg
  158.     ELSE
  159.         __LdAdr dx, ofset
  160.         IFNB    <segmnt>
  161.             __LdSeg ds, <segmnt>
  162.         ENDIF
  163.     ENDIF
  164.     mov     ah, 9
  165.     int     21h
  166. ENDM
  167.  
  168. ; 3Fh
  169. @Read MACRO ofset:REQ, bytes:REQ, handle:=<0>, segmnt
  170.     IFDIF   <handle>, <0>
  171.         mov     bx, handle
  172.     ELSE
  173.         sub     bx, bx
  174.     ENDIF
  175.     mov     cx, bytes
  176.     __LdAdr dx, <ofset>
  177.     IFNB    <segmnt>
  178.         __LdSeg ds, <segmnt>
  179.     ENDIF
  180.     mov     ah, 3Fh
  181.     int     21h
  182. ENDM
  183.  
  184. ; 40h
  185. @Write MACRO ofset:REQ, bytes:REQ, handle:=<1>, segmnt
  186.     mov     bx, handle
  187.     mov     cx, bytes
  188.     __LdAdr dx, <ofset>
  189.     IFNB    <segmnt>
  190.         __LdSeg ds, <segmnt>
  191.     ENDIF
  192.     mov     ah, 40h
  193.     int     21h
  194. ENDM
  195.  
  196. ; 3Ch, 5Ah, 5Bh
  197. @MakeFile MACRO path:REQ, atrib:=<0>, segmnt, kind
  198.     IFDIF   <atrib>, <0>
  199.         mov     cx, atrib
  200.     ELSE
  201.         sub     cx, cx
  202.     ENDIF
  203.     __LdAdr dx, <path>
  204.     IFNB    <segmnt>
  205.         __LdSeg ds, <segmnt>
  206.     ENDIF
  207.     IFIDNI  <kind>, <tmp>
  208.         mov     ah, 5Ah
  209.     ELSEIFIDNI <kind>, <new>
  210.         mov    ah, 5Bh
  211.     ELSE
  212.         mov    ah, 3Ch
  213.     ENDIF
  214.     int     21h
  215. ENDM
  216.  
  217. ; 3Dh
  218. @OpenFile MACRO path:REQ, access:=<0>, segmnt
  219.     __LdAdr dx, <path>
  220.     IFNB    <segmnt>
  221.         __LdSeg ds, <segmnt>
  222.     ENDIF
  223.     mov     ax, 3D00h + (access AND 0FFh)
  224.     int     21h
  225. ENDM
  226.  
  227. ; 3Eh
  228. @CloseFile MACRO handle:REQ
  229.     mov     bx, handle
  230.     mov     ah, 3Eh
  231.     int     21h
  232. ENDM
  233.  
  234. ; 41h
  235. @DelFile MACRO path:REQ, segmnt
  236.     __LdAdr dx, <path>
  237.     IFNB    <segmnt>
  238.         __LdSeg ds, <segmnt>
  239.     ENDIF
  240.     mov     ah, 41h
  241.     int     21h
  242. ENDM
  243.  
  244. ; 56h
  245. @MoveFile MACRO old:REQ, new:REQ, segold, segnew
  246.     __LdAdr dx, <old>
  247.     __LdAdr di, <new>
  248.     IFNB    <segold>
  249.         __LdSeg ds, <segold>
  250.     ENDIF
  251.     IFNB    <segnew>
  252.         __LdSeg es, <segnew>
  253.     ENDIF
  254.     mov     ah, 56h
  255.     int     21h
  256. ENDM
  257.  
  258.  
  259. ;* File information returned from GetFirst procedure
  260. FILE_INFO       STRUCT
  261.   pad           BYTE    21 DUP (?)      ; pad to 43 bytes
  262.   Attrib        BYTE    ?               ; file attribute
  263.   Time          WORD    ?               ; file time
  264.   Date          WORD    ?               ; file date
  265.   Len           DWORD   ?               ; file size
  266.   FName         BYTE    13 DUP (?)      ; file name
  267. FILE_INFO       ENDS
  268.  
  269. ; 4Eh
  270. @GetFirst MACRO path:REQ, atrib, segmnt
  271.     IFNB    <atrib>
  272.         mov     cx, atrib
  273.     ELSE
  274.         sub     cx, cx
  275.     ENDIF
  276.     __LdAdr dx, <path>
  277.     IFNB    <segmnt>
  278.         __LdSeg ds, <segmnt>
  279.     ENDIF
  280.     mov     ah, 4Eh
  281.     int     21h
  282. ENDM
  283.  
  284.  
  285. ; 4Fh
  286. @GetNext MACRO
  287.     mov     ah, 4Fh
  288.     int     21h
  289. ENDM
  290.  
  291. ; 2Fh
  292. @GetDTA MACRO
  293.     mov     ah, 2Fh
  294.     int     21h
  295. ENDM
  296.  
  297. ; 1Ah
  298. @SetDTA MACRO buffer:REQ, segmnt
  299.     __LdAdr dx, <buffer>
  300.     IFNB    <segmnt>
  301.         __LdSeg ds, <segmnt>
  302.     ENDIF
  303.     mov     ah, 1Ah
  304.     int     21h
  305. ENDM
  306.  
  307. ; 42h
  308. @GetFileSize MACRO handle:REQ
  309.     mov     bx, handle
  310.     sub     cx, cx
  311.     sub     dx, dx
  312.     mov     ax, 4202h
  313.     int     21h
  314.     push    dx
  315.     push    ax
  316.     sub     dx, dx
  317.     mov     ax, 4200h
  318.     int     21h
  319.     pop     ax
  320.     pop     dx
  321. ENDM
  322.  
  323. ; 42h
  324. @MovePtrAbs MACRO handle:REQ, distance
  325.     IFNB    <distance>
  326.         __LdDub <distance>
  327.     ENDIF
  328.     mov     bx, handle
  329.     mov     ax, 4200h
  330.     int     21h
  331. ENDM
  332.  
  333. ; 42h
  334. @MovePtrRel MACRO handle:REQ, distance
  335.     IFNB    <distance>
  336.         __LdDub <distance>
  337.     ENDIF
  338.     mov     bx, handle
  339.     mov     ax, 4201h
  340.     int     21h
  341. ENDM
  342.  
  343. ; 39h
  344. @MkDir MACRO path:REQ, segmnt
  345.     __LdAdr dx, <path>
  346.     IFNB    <segmnt>
  347.         __LdSeg ds, <segmnt>
  348.     ENDIF
  349.     mov     ah, 39h
  350.     int     21h
  351. ENDM
  352.  
  353. ; 3Ah
  354. @RmDir MACRO path:REQ, segmnt
  355.     __LdAdr dx, <path>
  356.     IFNB    <segmnt>
  357.         __LdSeg ds, <segmnt>
  358.     ENDIF
  359.     mov     ah, 3Ah
  360.     int     21h
  361. ENDM
  362.  
  363. ; 3Bh
  364. @ChDir MACRO path:REQ, segmnt
  365.     __LdAdr dx, <path>
  366.     IFNB    <segmnt>
  367.         __LdSeg ds, <segmnt>
  368.     ENDIF
  369.     mov     ah, 3Bh
  370.     int     21h
  371. ENDM
  372.  
  373. ; 47h
  374. @GetDir MACRO buffer:REQ, drive, segmnt
  375.     IFNB    <drive>
  376.         mov     dl, drive
  377.     ELSE
  378.         sub     dl, dl
  379.     ENDIF
  380.     __LdAdr si, <buffer>
  381.     IFNB    <segmnt>
  382.         __LdSeg ds, <segmnt>
  383.     ENDIF
  384.     mov     ah, 47h
  385.     int     21h
  386. ENDM
  387.  
  388. ; 19h
  389. @GetDrv MACRO
  390.     mov     ah, 19h
  391.     int     21h
  392. ENDM
  393.  
  394. ; 0Eh
  395. @SetDrv MACRO drive:REQ
  396.     mov     dl, drive
  397.     mov     ah, 0Eh
  398.     int     21h
  399. ENDM
  400.  
  401. ; 1Ch
  402. @ChkDrv MACRO drive
  403.     IFNB    <drive>
  404.         mov     dl, drive
  405.     ELSE
  406.         sub     dl, dl
  407.     ENDIF
  408.     mov     ah, 1Ch
  409.     int     21h
  410. ENDM
  411.  
  412. ; 4Ch
  413. @Exit MACRO return
  414.     IFB     <return>
  415.         mov     ah, 4Ch
  416.     ELSE
  417.         mov     ax, 4C00h + (return AND 0FFh)
  418.     ENDIF
  419.     int     21h
  420. ENDM
  421.  
  422. ; 31h
  423. @TSR MACRO paragraphs:REQ, return
  424.     mov     dx, paragraphs
  425.     IFB     <return>
  426.         mov     ah, 31h
  427.     ELSE
  428.         mov     ax, 3100h + (return AND 0FFh)
  429.     ENDIF
  430.     int     21h
  431. ENDM
  432.  
  433. ; 49h
  434. @FreeBlock MACRO segmnt
  435.     IFNB    <segmnt>
  436.         __LdSeg es, <segmnt>
  437.     ENDIF
  438.     mov     ah, 49h
  439.     int     21h
  440. ENDM
  441.  
  442. ; 48h
  443. @GetBlock MACRO graphs:REQ, retry:=<0>
  444.     LOCAL   tryit
  445.     mov     bx, graphs
  446.     tryit:  mov     ah, 48h
  447.     int     21h
  448.  
  449.     IF        retry
  450.     jc  tryit
  451.     ENDIF
  452. ENDM
  453.  
  454. ; 4Ah
  455. @ModBlock MACRO graphs:REQ, segmnt
  456.     IFNB    <segmnt>
  457.         __LdSeg es, <segmnt>
  458.     ENDIF
  459.     mov     bx, graphs
  460.     mov     ah, 4Ah
  461.     int     21h
  462. ENDM
  463.  
  464. ; 2Ah
  465. @GetDate MACRO
  466.     mov     ah, 2Ah
  467.     int     21h
  468. ENDM
  469.  
  470. ; 2Bh
  471. @SetDate MACRO month:REQ, day:REQ, year:REQ
  472.     mov     cx, year
  473.     mov     dh, month
  474.     mov     dl, day
  475.     mov     ah, 2Bh
  476.     int     21h
  477. ENDM
  478.  
  479. ; 2Ch
  480. @GetTime MACRO
  481.     mov     ah, 2Ch
  482.     int     21h
  483. ENDM
  484.  
  485. ; 2Dh
  486. @SetTime MACRO hour:REQ, minutes:REQ, seconds:REQ, hundredths:REQ
  487.     mov     ch, hour
  488.     mov     cl, minutes
  489.     mov     dh, seconds
  490.     mov     dl, hundredths
  491.     mov     ah, 2Dh
  492.     int     21h
  493. ENDM
  494.  
  495. ; 30h
  496. @GetVer MACRO
  497.     mov     ah, 30h
  498.     int     21h
  499. ENDM
  500.  
  501. ; 35h
  502. @GetInt MACRO   interrupt:REQ
  503.     mov     ax, 3500h + (interrupt AND 0FFh)
  504.     int     21h
  505. ENDM
  506.  
  507. ; 25h
  508. @SetInt MACRO interrupt:REQ, vector:REQ, segmnt
  509.     IF  (TYPE (vector) EQ NPVOID) OR (TYPE (vector) EQ FPVOID)
  510.         mov     dx, OFFSET vector
  511.         mov     ax, SEG vector
  512.         mov     ds, ax
  513.     ELSE
  514.         __LdAdr dx, <vector>
  515.         IFNB    <segmnt>
  516.             __LdSeg ds, <segmnt>
  517.         ENDIF
  518.     ENDIF
  519.     mov     ax, 2500h + (interrupt AND 0FFh)
  520.     int     21h
  521. ENDM
  522.