home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / magazine / drdobbs / 1990 / 03 / hyde.lst < prev    next >
File List  |  1990-02-13  |  12KB  |  557 lines
  1. OBJECT-ORIENTED PROGRAMMING IN ASSEMBLY LANGUAGE
  2. by Randall L. Hyde
  3.  
  4.  
  5. [LISTING ONE]
  6.  
  7. [LISTING ONE]
  8.  
  9.         page    62, 132
  10. ;
  11. ;****************************************************************************
  12. ; OBJECTS.ASM  -- This program demonstrates object-oriented programming 
  13. ; techniques in 8086 assembly language.
  14. ;
  15. dseg            segment byte public 'data'
  16. ;
  17. ; Unsigned Data Type:
  18. Unsigned        struc
  19. Value           dw      0
  20. _Get_           dd      ?       ;AX = This
  21. _Put_           dd      ?       ;This = AX
  22. _Add_           dd      ?       ;AX = AX + This
  23. _Sub_           dd      ?       ;AX = AX - This
  24. _Eq_            dd      ?       ;Zero flag = AX == This
  25. _Lt_            dd      ?       ;Zero flag = AX < This
  26. Unsigned        ends
  27. ;
  28. ; UVar lets you (easily) declare an unsigned variable.
  29. UVar            macro    var
  30. var             Unsigned <,uGet,uPut,uAdd,uSub,uEq,uLt>
  31.         endm
  32. ;
  33. ; Signed Data Type:
  34. Signed          struc
  35.         dw      0
  36.         dd      ?       ;Get method
  37.         dd      ?       ;Put method
  38.         dd      ?       ;Add method
  39.         dd      ?       ;Sub method
  40.         dd      ?       ;Eq method
  41.         dd      ?       ;Lt method
  42. Signed          ends
  43. ;
  44. ; SVar lets you easily declare a signed variable.
  45. SVar            macro   var
  46. var             Signed  <,sGet, sPut, sAdd, sSub, sEq, sLt>
  47.         endm
  48. ;
  49. ; BCD Data Type:
  50. BCD             struc
  51.         dw      0       ;Value
  52.         dd      ?       ;Get method
  53.         dd      ?       ;Put method
  54.         dd      ?       ;Add method
  55.         dd      ?       ;Subtract method
  56.         dd      ?       ;Eq method
  57.         dd      ?       ;Lt method
  58. BCD             ends
  59. ;
  60. ; BCDVar lets you (easily) declare a BCD variable.
  61. BCDVar          macro   var
  62. var             BCD     <,bGet, bPut, bAdd, bSub, bEq, bLt>
  63.         endm
  64. ;
  65. ; Declare variables of the appropriate types (For the sample pgm below):
  66. ; Also declare a set of DWORD values which point at each of the variables.
  67. ; This provides a simple mechanism for obtaining the address of an object.
  68.         UVar    u1
  69. U1Adr           dd      U1              ;Provide convenient address for U1.
  70. ;
  71.         UVar    u2
  72. U2Adr           dd      U2              ;Ditto for other variables.
  73. ;
  74.         SVar    s1
  75. S1Adr           dd      s1
  76. ;
  77.         SVar    s2
  78. S2Adr           dd      s2
  79. ;
  80.         BCDVar  b1
  81. B1Adr           dd      b1
  82. ;
  83.         BCDVar  b2
  84. B2Adr           dd      b2
  85. ;
  86. ; Generic Pointer Variables:
  87. Generic1        dd      ?
  88. Generic2        dd      ?
  89. ;
  90. dseg            ends
  91. ;
  92. cseg            segment byte public 'CODE'
  93.                 assume  cs:cseg, ds:dseg, es:dseg, ss:sseg
  94. ;
  95. _This           equ     es:[bx]         ;Provide a mnemonic name for THIS.
  96. ;
  97. ; Macros to simplify calling the various methods
  98. _Get            macro
  99.         call    _This._Get_
  100.         endm
  101. ;
  102. _Put            macro
  103.         call    _This._Put_
  104.         endm
  105. ;
  106. _Add            macro
  107.         call    _This._Add_
  108.         endm
  109. ;
  110. _Sub            macro
  111.         call    _This._Sub_
  112.         endm
  113. ;
  114. _Eq             macro
  115.         call    _This._Eq_
  116.         endm
  117. ;
  118. _Lt             macro
  119.         call    _This._Lt_
  120.         endm
  121. ;
  122. ;****************************************************************************
  123. ; Methods for the unsigned data type:
  124. uGet            proc    far
  125.         mov     ax, _This
  126.         ret
  127. uGet            endp
  128. ;
  129. uPut            proc    far
  130.         mov     _This,ax
  131.         ret
  132. uPut            endp
  133. ;
  134. uAdd            proc    far
  135.         add     ax, _This
  136.         ret
  137. uAdd            endp
  138. ;
  139. uSub            proc    far
  140.         sub     ax, _This
  141.         ret
  142. uSub            endp
  143. ;
  144. uEq             proc    far
  145.         cmp     ax, _This
  146.         ret
  147. uEq             endp
  148. ;
  149. uLt             proc    far
  150.         cmp     ax, _This
  151.         jb      uIsLt
  152.         cmp     ax, 0           ;Force Z flag to zero.
  153.         jne     uLtRtn
  154.         cmp     ax, 1
  155. uLtRtn:         ret
  156. ;
  157. uIsLt:          cmp     ax, ax          ;Force Z flag to one.
  158.         ret
  159. uLt             endp
  160. ;
  161. ;****************************************************************************
  162. ; Methods for the unsigned data type.
  163. sPut            equ     uPut            ;Same code, why duplicate it?
  164. sGet            equ     uGet
  165. sAdd            equ     uAdd
  166. sSub            equ     uSub
  167. sEq             equ     uEq
  168. ;
  169. sLt             proc    far
  170.         cmp     ax, _This
  171.         jl      sIsLt
  172.         cmp     ax, 0           ;Force Z flag to zero.
  173.         jne     sLtRtn
  174.         cmp     ax, 1
  175. sLtRtn:         ret
  176. ;
  177. sIsLt:          cmp     ax, ax          ;Force Z flag to one.
  178.         ret
  179. sLt             endp
  180. ;
  181. ;****************************************************************************
  182. ; Methods for the BCD data type
  183. bGet            equ     uGet            ;Same code, don't duplicate it.
  184. bPut            equ     uPut
  185. bEq             equ     uEq
  186. bLt             equ     uLt
  187. ;
  188. bAdd            proc    far
  189.         add     ax, _This
  190.         daa
  191.         ret
  192. bAdd            endp
  193. ;
  194. bSub            proc    far
  195.         sub     ax, _This
  196.         das
  197.         ret
  198. bSub            endp
  199. ;
  200. ;****************************************************************************
  201. ; Test code for this program:
  202. TestSample      proc    near
  203.         push    ax
  204.         push    bx
  205.         push    es
  206. ;
  207. ; Compute "Generic1 = Generic1 + Generic2;"
  208.         les     bx, Generic1
  209.         _Get
  210.         les     bx, Generic2
  211.         _Add
  212.         les     bx, Generic1
  213.         _Put
  214. ;
  215.         pop     es
  216.         pop     bx
  217.         pop     ax
  218.         ret
  219. TestSample      endp
  220. ;
  221. ; Main driver program
  222. MainPgm         proc    far
  223.         mov     ax, dseg
  224.         mov     ds, ax
  225. ;
  226. ; Initialize the objects:
  227. ; u1 = 39876.  Also initialize Generic1 to point at u1 for later use.
  228.         les     bx, U1Adr
  229.         mov     ax, 39876
  230.         _Put
  231.         mov     word ptr Generic1, bx
  232.         mov     word ptr Generic1+2, es
  233. ;
  234. ; u2 = 45677.  Also point Generic2 at u2 for later use.
  235.         les     bx, U2Adr
  236.         mov     ax, 45677
  237.         _Put
  238.         mov     word ptr Generic2, bx
  239.         mov     word ptr Generic2+2, es
  240. ;
  241. ; s1 = -5.
  242.         les     bx, S1Adr
  243.         mov     ax, -5
  244.         _Put
  245. ;
  246. ; s2 = 12345.
  247.         les     bx, S2Adr
  248.         mov     ax, 12345
  249.         _Put
  250. ;
  251. ; b1 = 2899.
  252.         les     bx, B1Adr
  253.         mov     ax, 2899h
  254.         _Put
  255. ;
  256. ; b2 = 195.
  257.         les     bx, B2Adr
  258.         mov     ax, 195h
  259.         _Put
  260. ;
  261. ; Call TestSample to add u1 & u2.
  262.          call    TestSample
  263. ;
  264. ; Call TestSample to add s1 & s2.
  265.         les     bx, S1Adr
  266.         mov     word ptr Generic1, bx
  267.         mov     word ptr Generic1+2, es
  268.         les     bx, S2Adr
  269.         mov     word ptr Generic2, bx
  270.         mov     word ptr Generic2+2, es
  271.         call    TestSample
  272. ;
  273. ; Call TestSample to add b1 & b2.
  274.         les     bx, B1Adr
  275.         mov     word ptr Generic1, bx
  276.         mov     word ptr Generic1+2, es
  277.         les     bx, B2Adr
  278.         mov     word ptr Generic2, bx
  279.         mov     word ptr Generic2+2, es
  280.         call    TestSample
  281. ;
  282.         mov     ah, 4ch                 ;Terminate process DOS cmd.
  283.         int     21h
  284. ;
  285. ;
  286. MainPgm         endp
  287. cseg            ends
  288. ;
  289. sseg            segment byte stack 'stack'
  290. stk             dw      0f0h dup (?)
  291. endstk          dw      ?
  292. sseg            ends
  293. ;
  294.                 end     MainPgm
  295.  
  296.  
  297.  
  298. [Example 1] 
  299.  
  300. struct 
  301. {
  302.        int i;
  303.        int j;
  304.        char *c;
  305. } S;
  306.  
  307.  
  308. [Example 2]
  309.  
  310. SType  struc
  311. i      dw    ?
  312. j      dw    ?
  313. c      dd    ?
  314. SType  ends
  315.  
  316. [Example 3]
  317.  
  318. class Sc 
  319. {
  320.           int i;
  321.           int j;
  322.           char *c;
  323. };
  324.  
  325. Sc *pS;
  326. Tc *pT;
  327.  
  328.  
  329. Tclass Tc:Sc
  330. {
  331.            int k;
  332.            char *d;
  333. };
  334.  
  335.  
  336. [Example 4]
  337.  
  338. struct Tc                Tc   struc
  339. {                        i    dw      ?
  340.       int i;             j    dw      ?
  341.       int j;             c    dd      ?
  342.       char *c;           k    dw      ?
  343.       int k;             d    dd      ?
  344.       char *d            Tc   ends
  345. };
  346.  
  347.  
  348.  
  349.  
  350. [Example 5]
  351.  
  352. ScItems macro
  353. i       dw       ?
  354. j       dw       ?
  355. c       dd       ?
  356. endm
  357.  
  358. ;
  359. TcItems   macro
  360.        ScItems
  361. k         dw      ?
  362. d         dd      ?
  363.           endm
  364.  
  365. ;
  366. Sc         struc
  367.            ScItems
  368. Sc         ends
  369. ;
  370. Tc         struc
  371.            TcItems
  372. Tc         ends
  373.  
  374.  
  375. [Example 6]
  376.  
  377. Sc          struc
  378. i           dw        ?
  379. j           dw        ?
  380. c           dd        ?
  381. Sc          ends
  382.  
  383. Tc          struc
  384. i           dw         ?
  385. j           dw         ?
  386. c           dd         ?
  387. k           dw         ?
  388. d           dd         ?
  389. Tc          ends
  390.  
  391.  
  392. [Example 7]
  393.  
  394. Sc      struc
  395. i       dw         ?
  396. j       dw         ?
  397. c       dd         ?
  398. Sc      ends
  399.  
  400. Tc      struc  
  401.         dw          ?
  402.         dw          ?
  403.         dd          ?
  404. k       dw          ?
  405. d       dd          ?
  406. Tc      ends
  407.  
  408. S       Sc
  409. T       Tc
  410.  
  411.  
  412. [Example 8]
  413.  
  414. Sc       struc
  415. i        dw       ?
  416. j        dw       ?
  417. c        dd       ?
  418. Sc       ends
  419.  
  420. Tc       struc
  421.          db       (size Sc) dup (?)
  422. k        dw       ?
  423. d        dd       ?
  424. Tc       ends
  425.  
  426. Uc       struc
  427.          db       (size Tc) dup (?)
  428. e        dw       ?
  429. Uc       ends
  430.  
  431. S        Sc
  432. T        Tc
  433. U        Uc
  434.  
  435. [Example 9]
  436.  
  437. class Sc
  438. {
  439.       int i,j;
  440.       char *c;
  441.  
  442.       public:
  443.  
  444.       int geti() {return i};   /* Ignore the fact that C++ */
  445.       int getj() {return j};   /* would implement these    */
  446.       void seti(x) int x; {i = x;};  /* methods in-line.   */
  447.       void setj(x) int x; {j = x;};
  448. };
  449.  
  450.  
  451. [Example 10]
  452.  
  453. Sc     struc
  454. i      dw         ?
  455. j      dw         ?
  456. c      dd         ?
  457. geti   dd         Sc_geti
  458. getj   dd         Sc_getj
  459. seti   dd         Sc_seti
  460. setj   dd         Sc_setj
  461. Sc     ends
  462.  
  463. S      Sc
  464.  
  465. [Example 11]
  466.  
  467. _THIS       equ       es:[bx]
  468. Sc_geti     proc      far  
  469.             mov       ax, _THIS.i
  470.             ret
  471. Sc_geti     endp
  472.  
  473.  
  474. [Example 12]
  475.  
  476. mov      bx, seg S1
  477. mov      es, bx
  478. mov      bx, offset S1
  479. call     S1.geti          ;Assuming S1 is in the data seg.
  480.  
  481.  
  482. [Example 13]
  483.  
  484. ;
  485. ; Inline expansion of geti to improve efficiency:
  486. ;
  487. _Geti                  macro
  488.                        mov               ax, _THIS.i
  489.                        endm
  490. ;
  491. ; Perform actual call to routines which are too big to
  492. ; expand in-line in our code:
  493. ;
  494. _Printi                macro
  495.                        call             _THIS.Printi
  496.                        endm
  497.                           .
  498.                           .
  499.                           .
  500.                        _Geti           ;Get i into AX.
  501.                           .
  502.                           .
  503.                           .
  504.                       _Printi          ;Call Printi routine.
  505.  
  506.  
  507. [Example 14]
  508.  
  509. Shape       struc
  510. ulx         dw        ?     ;Upper left X coordinate
  511. uly         dw        ?     ;Upper left Y coordinate
  512. lrx         dw        ?     ;Lower right X coordinate
  513. lry         dw        ?     ;Lower right Y coordinate
  514. Draw        dd        Shape_Draw   ;Default (overridden) DRAW routine
  515. Shape       ends
  516. ;
  517. Rect        struc
  518.             dw        4 dup (?)    ;Reserve space for coordinates 
  519.             dd        Rect_Draw    ;Draw a rectangle
  520. Rect        ends
  521. ; 
  522. Circle      struc
  523.             dw        4 dup (?)    ;Reserve space for coordinates 
  524.             dd        Circle_Draw  ;Draw a circle
  525. Circle      ends
  526.  
  527.  
  528. [Example 15]
  529.  
  530.                mov      cx, size rect
  531.                call     alloc
  532.                mov      word ptr MyRectPtr, bx
  533.                mov      word ptr MyRectPtr+2, es
  534.  
  535.  
  536. [Example 16]
  537.  
  538.               mov        ax, offset rectDRAW
  539.               mov        _this.DRAW, ax
  540.               mov        ax, seg rectDRAW
  541.               mov        _this.DRAW+2, ax
  542.  
  543. [Example 17]
  544.  
  545.                  mov       cx, size circle
  546.                  call      CreateCircle
  547.                  mov       word ptr CircVarPtr, bx
  548.                  mov       word ptr CircVarPtr+2, es
  549. ; 
  550.                  mov       cx, size rect
  551.                  call      CreateRect
  552.                  mov       word ptr RectVarPtr, bx
  553.                  mov       word ptr RectVarPtr+2, es
  554.  
  555.  
  556.  
  557.