home *** CD-ROM | disk | FTP | other *** search
/ Reverse Code Engineering RCE CD +sandman 2000 / ReverseCodeEngineeringRceCdsandman2000.iso / RCE / Library / Manuels & Misc / Assembly / AOA.ZIP / CH12 / EX12_1.ASM next >
Encoding:
Assembly Source File  |  1996-02-18  |  8.1 KB  |  399 lines
  1. ; EX12_1.asm
  2. ;
  3. ; Program to support the laboratory exercise in Chapter 12.
  4. ;
  5. ; This program combines iterators, passing parameters as parameters,
  6. ; and procedural parameters all into the same program.
  7. ;
  8. ;
  9. ; This program implements the following iterators (examples written in panacea):
  10. ;
  11. ; program EX12_1;
  12. ;
  13. ; fib:iterator(n:integer):integer;
  14. ; var
  15. ;    CurIndex:integer;
  16. ;    Fn1:     integer;
  17. ;    Fn2:     integer;
  18. ; endvar;
  19. ; begin fib;
  20. ;
  21. ;    yield 1;    (* Always have at least n=0 *)
  22. ;    if (n <> 0) then
  23. ;
  24. ;        yield 1;    (* Have at least n=1 at this point *)
  25. ;
  26. ;        Fn1 := 1;
  27. ;        Fn2 := 1;
  28. ;        foreach CurIndex in 2..n do
  29. ;
  30. ;            yield Fn1+Fn2;
  31. ;            Fn2 = Fn1;
  32. ;            Fn1 = CurIndex;
  33. ;
  34. ;        endfor;
  35. ;    endif;
  36. ;
  37. ; end fib;
  38. ;
  39. ;
  40. ;
  41. ; UpDown:iterator(n:integer):integer;
  42. ; var
  43. ;    CurIndex:integer;
  44. ; endvar;
  45. ; begin UpDown;
  46. ;
  47. ;    foreach CurIndex in 0..n do
  48. ;
  49. ;        yield CurIndex;
  50. ;
  51. ;    endfor;
  52. ;    foreach CurIndex in n-1..0 do
  53. ;
  54. ;        yield CurIndex;
  55. ;
  56. ;    endfor;
  57. ; 
  58. ; end UpDown;
  59. ;
  60. ;
  61. ;
  62. ; SumToN:iterator(n:integer):integer;
  63. ; var
  64. ;    CurIndex:integer;
  65. ;    Sum:     integer;
  66. ; endvar;
  67. ; begin SumToN;
  68. ;
  69. ;    Sum := 0;
  70. ;    foreach CurIndex in 0..n do
  71. ;
  72. ;        Sum := Sum + CurIndex;
  73. ;        yield Sum;
  74. ;
  75. ;    endfor;
  76. ;
  77. ; end SumToN;
  78. ;
  79. ;
  80. ; MultiIter returns a pointer to an iterator that accepts a single integer parameter.
  81. ;
  82. ; MultiIter: iterator: [iterator(n:integer)];
  83. ; begin MultiIter;
  84. ;
  85. ;    yield @Fib;    (* Return pointers to the three iterators above *)
  86. ;    yield @UpDown;    (* as the result of this iterator.        *)
  87. ;    yield @SumToN;
  88. ;
  89. ; end MultiIter;
  90. ;
  91. ;
  92. ; var
  93. ;    i:integer;
  94. ;    n:integer;
  95. ;    iter:[iterator(n:integer)];
  96. ; endvar;
  97. ;
  98. ; begin EX12_1;
  99. ;
  100. ;    (* The following for loop repeats six times, passing its loop index as    *)
  101. ;    (* the parameter to the Fib, UpDown, and SumToN parameters.        *)
  102. ;
  103. ;    foreach n in 0..5 do
  104. ;
  105. ;
  106. ;        (* The following (funny looking) iterator sequences through    *)
  107. ;        (* each of the three iterators: Fib, UpDown, and SumToN.  It    *)
  108. ;        (* returns a pointer as the iterator value.  The innermost    *)
  109. ;        (* foreach loop uses this pointer to call the appropriate    *)
  110. ;        (* iterator.                            *)
  111. ;
  112. ;        foreach iter in MultiIter do
  113. ;
  114. ;            (* Okay, this for loop invokes whatever iterator was    *)
  115. ;            (* return by the MultiIter iterator above.        *)
  116. ;
  117. ;            foreach i in [MultiIter](n) do
  118. ;
  119. ;                write(i:3);
  120. ;
  121. ;            endfor;
  122. ;            writeln;
  123. ;
  124. ;        endfor;
  125. ;        writeln;
  126. ;
  127. ;    endfor;
  128. ;
  129. ; end EX12_1;
  130.  
  131.         .xlist
  132.         include     stdlib.a
  133.         includelib    stdlib.lib
  134.         .list
  135.  
  136.         .286                ;Allow extra adrs modes.
  137.  
  138.  
  139. wp        textequ    <word ptr>
  140.  
  141.  
  142. dseg        segment    para public 'code'
  143. dseg        ends
  144.  
  145.  
  146. cseg        segment    para public 'code'
  147.         assume    cs:cseg, ss:sseg
  148.  
  149.  
  150.  
  151.  
  152. ; The following macro builds a resume frame and the returns to the caller
  153. ; of an iterator.  It assumes that the iterator and whoever called the
  154. ; iterator have the standard activation record defined above and that we
  155. ; are building the standard resume frame described above.
  156. ;
  157. ; This code wipes out the DX register.  Whoever calls the iterator cannot
  158. ; count on DX being preserved, likewise, the iterator cannot count on DX
  159. ; being preserved across a yield.  Presumably, the iterator returns its
  160. ; value in AX.
  161.  
  162.  
  163. Yield        macro
  164.                 mov     dx, [BP+2]              ;Place to yield back to.
  165.         push    bp            ;Save Iterator link
  166.                 mov     bp, [bp]                ;Get ptr to caller's A.R.
  167.         call    dx            ;Push resume address and rtn.
  168.         pop    bp            ;Restore ptr to our A. R.
  169.         endm
  170.  
  171.  
  172.  
  173.  
  174.  
  175.  
  176. ; Fib(n) - Yields the sequence of fibonacci numbers from F(0)..F(n).
  177. ;       The fibonacci sequence is defined as:
  178. ;
  179. ;        F(0) and F(1) = 1.
  180. ;        F(n) = F(n-1) + F(n-2) for n > 1.
  181.  
  182.  
  183. ; The following structure defines the activation record for Fib
  184.  
  185. CurIndex    textequ    <[bp-6]>    ;Current sequence value.
  186. Fn1        textequ    <[bp-4]>    ;F(n-1) value.
  187. Fn2        textequ    <[bp-2]>    ;F(n-2) value.
  188. DynamicLink    textequ    <[bp]>        ;Saved BP value.
  189. YieldAdrs    textequ    <[bp+2]>    ;Return Adrs for proc.
  190. FailAdrs        textequ <[bp+4]>        ;Go here when we fail
  191. n               textequ <[bp+6]>        ;The initial parameter
  192.  
  193.  
  194. Fib        proc
  195.         push    bp
  196.         mov    bp, sp
  197.         sub    sp, 6        ;Make room for local variables.
  198.  
  199. ; We will also begin yielding values starting at F(0).
  200. ; Since F(0) and F(1) are special cases, yield their values here.
  201.  
  202.         mov    ax, 1        ;Yield F(0) (we always return at least
  203.         yield            ; F(0)).
  204.  
  205.         cmp    wp n, 1        ;See if user called this with n=0.
  206.         jb    FailFib
  207.                 mov     ax, 1
  208.                 yield
  209.  
  210. ; Okay, n >=1 so we need to go into a loop to handle the remaining values.
  211. ; First, begin by initializing Fn1 and Fn2 as appropriate.
  212.  
  213.                 mov     wp Fn1, 1
  214.                 mov     wp Fn2, 1
  215.                 mov     wp CurIndex, 2
  216.  
  217. WhlLp:        mov     ax, CurIndex        ;See if CurIndex > n.
  218.                 cmp     ax, n
  219.                 ja      FailFib
  220.  
  221.                 push    Fn1
  222.                 mov     ax, Fn1
  223.                 add     ax, Fn2
  224.                 pop     Fn2            ;Fn1 becomes the new Fn2 value.
  225.                 mov     Fn1, ax            ;Current value becomes new Fn1 value.
  226.                 yield                ;Yield the current value.
  227.  
  228.                 inc     wp CurIndex
  229.                 jmp     WhlLp
  230.  
  231.  
  232.  
  233. FailFib:    mov     sp, bp            ;Deallocate local vars.
  234.                 pop     bp            ;Restore Dynamic Link.
  235.                 add     sp, 2            ;Skip ret adrs.
  236.                 ret     2            ;Return through fail address.
  237. Fib        endp
  238.  
  239.  
  240.  
  241.  
  242.  
  243. ; UpDown-       This function yields the sequence 0, 1, 2, ..., n, n-1,
  244. ;               n-2, ..., 1, 0.
  245.  
  246.  
  247. i               textequ <[bp-2]>        ;F(n-2) value.
  248.  
  249. UpDown        proc
  250.         push    bp
  251.         mov    bp, sp
  252.         sub    sp, 2        ;Make room for i.
  253.  
  254.         mov    wp i, 0        ;Initialize our index variable (i).
  255. UptoN:        mov    ax, i
  256.         cmp    ax, n
  257.         jae    GoDown
  258.  
  259.         yield
  260.  
  261.         inc    wp i
  262.         jmp    UpToN
  263.  
  264.  
  265. GoDown:        mov    ax, i
  266.         yield
  267.         mov    ax, i
  268.         cmp    ax, 0
  269.         je    UpDownDone
  270.         dec    wp i
  271.         jmp    GoDown
  272.  
  273. UpDownDone:     mov     sp, bp                  ;Deallocate local vars.
  274.                 pop     bp                      ;Restore Dynamic Link.
  275.                 add     sp, 2                   ;Skip ret adrs.
  276.                 ret     2                       ;Return through fail address.
  277. UpDown        endp
  278.  
  279.  
  280.  
  281.  
  282.  
  283. ; SumToN(n)-    This iterator returns 1, 2, 3, 6, 10, ... sum(n) where
  284. ;        sum(n) = 1+2+3+4+...+n  (e.g., n(n+1)/2);
  285.  
  286. j               textequ <[bp-2]>        
  287. k        textequ    <[bp-4]>
  288.  
  289. SumToN        proc
  290.         push    bp
  291.         mov    bp, sp
  292.         sub    sp, 4        ;Make room for j and k.
  293.  
  294.         mov    wp j, 0        ;Initialize our index variable (j).
  295.         mov    wp k, 0        ;Initialize our sum (k).
  296. SumLp:        mov    ax, j
  297.         cmp    ax, n
  298.         ja    SumDone
  299.  
  300.         add    ax, k
  301.         mov    k, ax
  302.  
  303.         yield
  304.  
  305.         inc    wp j
  306.         jmp    SumLp
  307.  
  308. SumDone:    mov     sp, bp                  ;Deallocate local vars.
  309.                 pop     bp                      ;Restore Dynamic Link.
  310.                 add     sp, 2                   ;Skip ret adrs.
  311.                 ret     2                       ;Return through fail address.
  312. SumToN        endp
  313.  
  314.  
  315.  
  316.  
  317.  
  318. ; MultiIter-    This iterator returns a pointer to each of the above iterators.
  319.  
  320. MultiIter    proc
  321.         push    bp
  322.         mov    bp, sp
  323.  
  324.         mov    ax, offset Fib
  325.         yield
  326.         mov    ax, offset UpDown
  327.         yield
  328.         mov    ax, offset SumToN
  329.         yield
  330.  
  331.         pop    bp
  332.         add    sp, 2
  333.         ret
  334. MultiIter    endp
  335.  
  336.  
  337.  
  338.  
  339. Main        proc
  340.         mov    ax, dseg
  341.         mov    ds, ax
  342.         mov    es, ax
  343.  
  344.  
  345.         meminit
  346.  
  347. ; foreach bx in 0..5 do
  348.  
  349.         mov    bx, 0         ;Loop control variable for outer loop.
  350. WhlBXle5:    
  351.  
  352. ; foreach ax in MultiIter do
  353.  
  354.         push    offset MultiDone ;Failure address.
  355.         call    MultiIter     ;Get iterator to call.
  356.  
  357.  
  358. ; foreach i in [ax](bx) do
  359.  
  360.         push    bx        ;Push "n" (bx) onto the stack.
  361.         push    offset IterDone    ;Failure Address
  362.         call    ax        ;Call the iterator pointed at by the
  363. ;                    ; return value from MultiIter.
  364. ;
  365. ; write(ax:3);
  366.  
  367.         mov    cx, 3
  368.         putisize    
  369.         ret
  370.  
  371. ; endfor, writeln;
  372.  
  373. IterDone:    putcr            ;Writeln;
  374.         ret
  375.  
  376. ; endfor, writeln;
  377.  
  378. MultiDone:    putcr
  379.         inc    bx
  380.         cmp    bx, 5
  381.         jbe    WhlBXle5
  382.  
  383. ; endfor
  384.  
  385. Quit:        ExitPgm            ;DOS macro to quit program.
  386. Main        endp
  387.  
  388. cseg            ends
  389.  
  390.  
  391. sseg        segment    para stack 'stack'
  392. stk        word    1024 dup (0)
  393. sseg        ends
  394.  
  395. zzzzzzseg    segment    para public 'zzzzzz'
  396. LastBytes    db    16 dup (?)
  397. zzzzzzseg    ends
  398.         end    Main
  399.