home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Database / CLIPR503.W96 / EXTENDA.IN_ / EXTENDA.IN
Text File  |  1995-06-26  |  16KB  |  1,130 lines
  1. ;
  2. ;   Extenda.inc
  3. ;
  4. ;   Clipper Summer87 Extend System definitions
  5. ;
  6. ;   Copyright (c) 1987-1993, Computer Associates International, Inc.
  7. ;   All rights reserved.
  8. ;
  9.  
  10.  
  11. .XLIST
  12. ;.LALL
  13.  
  14. $gen macro p1
  15. p1
  16. endm
  17.  
  18. $err macro m
  19.   if2
  20.     .err
  21.     %out (m)
  22.   endif
  23. endm
  24.  
  25.  
  26. SES macro p1, p2
  27.   $gen <        MOV    WORD PTR p2[2], ES>
  28.   $gen <        MOV    WORD PTR p2, p1>
  29. endm
  30.  
  31. SDS macro p1, p2
  32.   $gen <        MOV    WORD PTR p2[2], DS>
  33.   $gen <        MOV    WORD PTR p2, p1>
  34. endm
  35.  
  36.  
  37. DOSREQ macro p1
  38.   $gen <        MOV    AH, p1>
  39.   $gen <        INT    021H>
  40. endm
  41.  
  42. $define macro p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14
  43.   $gen <p1        EQU    p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14>
  44. endm
  45.  
  46.  
  47. $define PCOUNT        <<[WORD PTR [BP - 2]]>>
  48. $define OFFPART        <<WORD PTR>>
  49. $define SEGPART        <<WORD PTR [2]>>
  50. $define LSW        <<WORD PTR>>
  51. $define MSW        <<WORD PTR [2]>>
  52.  
  53.  
  54. $$lev = 0
  55. $$stat = 0
  56. $$work = 0
  57. $$cseg = 0
  58. $$dseg = 0
  59.  
  60.  
  61. CLextern macro p1
  62.  
  63.   irp $$item, <p1>
  64.     $x_&&$$item
  65.  
  66.   endm
  67. endm
  68.  
  69. $define $$UNDEF        0
  70. $define $$CHARACTER    1
  71. $define $$NUMERIC    2
  72. $define $$LOGICAL    4
  73. $define $$DATE        8
  74. $define $$ALIAS        16
  75. $define $$MPTR        32
  76. $define $$MEMO        65
  77. $define $$WORD        128
  78. $define $$ARRAY        512
  79.  
  80. CLextern <far _parinfo, far _parinfa, far _parc, far _parcsiz, far _parclen>
  81. CLextern <far _parni, far _parnl, far _parnd, far _parl, far _pards>
  82.  
  83. CLextern <far _retc, far _retclen, far _retni, far _retnl>
  84. CLextern <far _retnd, far _retl, far _retds, far _ret>
  85.  
  86. $cass macro
  87. endm
  88.  
  89. $dass macro
  90. endm
  91.  
  92. $cseg macro p1
  93.   if $$cseg
  94.     $err <already have CODESEG>
  95.  
  96.   else
  97.     $cbeg macro
  98.       $gen <p1        SEGMENT    BYTE PUBLIC 'CODE'>
  99.     endm
  100.  
  101.     $cass macro
  102.       $gen <        ASSUME    CS:&p1, DS:NOTHING, ES:NOTHING>
  103.     endm
  104.  
  105.     $cend macro
  106.       $gen <p1        ENDS>
  107.     endm
  108.  
  109.     $$cseg = 1
  110.  
  111.   endif
  112. endm
  113.  
  114. CODESEG macro p1
  115.   ifnb <p1>
  116.     $cseg p1&_TEXT
  117.  
  118.   else
  119.     $result macro p2
  120.       $cseg p2&&_TEXT
  121.     endm
  122.  
  123.     $result %@fileName
  124.     purge $result
  125.  
  126.   endif
  127. endm
  128.  
  129. $dseg macro p1
  130.   if $$dseg
  131.     $err <already have DATASEG>
  132.  
  133.   else
  134.     $gen <DGROUP        GROUP    p1>
  135.  
  136.     $dbeg macro
  137.       $gen <p1        SEGMENT    WORD PUBLIC 'DATA'>
  138.     endm
  139.  
  140.     $dass macro
  141.       $gen <        ASSUME    DS:DGROUP, ES:NOTHING>
  142.     endm
  143.  
  144.     $dend macro
  145.       $gen <p1        ENDS>
  146.     endm
  147.  
  148.     $$dseg = 1
  149.   endif
  150. endm
  151.  
  152. DATASEG macro p1
  153.   ifnb <p1>
  154.     $dseg p1
  155.  
  156.   else
  157.     $dseg _DATA
  158.  
  159.   endif
  160. endm
  161.  
  162. $static macro
  163.   if $$dseg EQ 0
  164.     $err <STATIC w/o DATASEG>
  165.  
  166.   else
  167.     if $$lev EQ 3
  168.       $err <STATIC within CLfunc must precede CLcode>
  169.  
  170.     else
  171.       if $$stat EQ 0
  172.         $dbeg
  173.         $dass
  174.         $$stat = 1
  175.       endif
  176.  
  177.     endif
  178.  
  179.   endif
  180. endm
  181.  
  182. $endstatic macro
  183.   if $$stat
  184.     $dend
  185.     $$stat = 0
  186.   endif
  187. endm
  188.  
  189. CLstatic macro p1
  190.   $static
  191.  
  192.   ifb <p1>
  193.   else
  194.     irp $$item, <p1>
  195.       $s_&&$$item
  196.  
  197.     endm
  198.   endif
  199. endm
  200.  
  201. $s_byte macro p1, p2
  202.   $gen <p1&_BYTE$    =    1>
  203.  
  204.   irp $$item, <p1>
  205.     ifdef $$item&&_PUBLIC$
  206.       ifnb <p2>
  207.     $gen <_&&$$item        DB    p2>
  208.  
  209.       else
  210.     $gen <_&&$$item        DB    0>
  211.  
  212.       endif
  213.  
  214.     else
  215.       ifnb <p2>
  216.     $gen <$$item        DB    p2>
  217.  
  218.       else
  219.     $gen <$$item        DB    0>
  220.  
  221.       endif
  222.     endif
  223.  
  224.   endm
  225. endm
  226.  
  227. $s_len macro p1, p2
  228.  
  229.   irp $$item, <p2>
  230.     ifdef $$item&&_PUBLIC$
  231.       $gen <p1        EQU    $-_&&$$item>
  232.  
  233.     else
  234.       $gen <p1        EQU    $-&&$$item>
  235.  
  236.     endif
  237.  
  238.   endm
  239. endm
  240.  
  241. $s_int macro p1, p2
  242.   $gen <p1&_BYTE$    =    2>
  243.  
  244.   irp $$item, <p1>
  245.     ifdef $$item&&_PUBLIC$
  246.       ifnb <p2>
  247.     $gen <_&&$$item        DW    p2>
  248.  
  249.       else
  250.     $gen <_&&$$item        DW    0>
  251.  
  252.       endif
  253.  
  254.     else
  255.       ifnb <p2>
  256.     $gen <$$item        DW    p2>
  257.  
  258.       else
  259.     $gen <$$item        DW    0>
  260.  
  261.       endif
  262.     endif
  263.  
  264.   endm
  265. endm
  266.  
  267. $s_log macro p1, p2
  268.   $s_int p1, <p2>
  269. endm
  270.  
  271. $s_long macro p1, p2
  272.   $gen <p1&_BYTE$    =    4>
  273.  
  274.   irp $$item, <p1>
  275.     ifdef $$item&&_PUBLIC$
  276.       ifnb <p2>
  277.     $gen <_&&$$item        DD    p2>
  278.  
  279.       else
  280.     $gen <_&&$$item        DD    0>
  281.  
  282.       endif
  283.  
  284.     else
  285.       ifnb <p2>
  286.     $gen <$$item        DD    p2>
  287.  
  288.       else
  289.     $gen <$$item        DD    0>
  290.  
  291.       endif
  292.     endif
  293.  
  294.   endm
  295. endm
  296.  
  297. $s_double macro p1, p2
  298.   $gen <p1&_BYTE$    =    8>
  299.  
  300.   irp $$item, <p1>
  301.     ifdef $$item&&_PUBLIC$
  302.       ifnb <p2>
  303.     $gen <_&&$$item        DQ    p2>
  304.  
  305.       else
  306.     $gen <_&&$$item        DQ    0>
  307.  
  308.       endif
  309.  
  310.     else
  311.       ifnb <p2>
  312.     $gen <$$item        DQ    p2>
  313.  
  314.       else
  315.     $gen <$$item        DQ    0>
  316.  
  317.       endif
  318.     endif
  319.  
  320.   endm
  321. endm
  322.  
  323. $s_cptr macro p1, p2
  324.   $gen <p1&_BYTE$    =    4>
  325.  
  326.   irp $$item, <p1>
  327.     ifdef $$item&&_PUBLIC$
  328.       ifnb <p2>
  329.     $gen <_&&$$item        DD    DGROUP:p2>
  330.  
  331.       else
  332.     $gen <_&&$$item        DD    0>
  333.  
  334.       endif
  335.  
  336.     else
  337.       ifnb <p2>
  338.     $gen <$$item        DD    DGROUP:p2>
  339.  
  340.       else
  341.     $gen <$$item        DD    0>
  342.  
  343.       endif
  344.     endif
  345.   endm
  346.  
  347.   $gen <p1&_OFF        EQU    WORD PTR p1>
  348.   $gen <p1&_SEG        EQU    WORD PTR p1[2]>
  349.   $gen <p1&_OFF_BYTE$        =    2>
  350.   $gen <p1&_SEG_BYTE$        =    2>
  351.  
  352. endm
  353.  
  354. $s_string macro p1, p2
  355.   $gen <p1&_BYTE$    =    1>
  356.  
  357.   irp $$item, <p1>
  358.     ifdef $$item&&_PUBLIC$
  359.       ifnb <p2>
  360.     $gen <_&&$$item        DB    p2,0>
  361.  
  362.       else
  363.     $gen <_&&$$item        DB    0>
  364.  
  365.       endif
  366.  
  367.     else
  368.       ifnb <p2>
  369.     $gen <$$item        DB    p2,0>
  370.  
  371.       else
  372.     $gen <$$item        DB    0>
  373.  
  374.       endif
  375.     endif
  376.  
  377.   endm
  378. endm
  379.  
  380. WORKFUNCS macro
  381.   if $$lev
  382.     $err <WORKFUNCS within CLfunc/CLret>
  383.  
  384.   else
  385.     if $$stat
  386.       $endstatic
  387.     endif
  388.  
  389.     if $$cseg EQ 0
  390.       CODESEG
  391.     endif
  392.  
  393.     if $$work EQ 0
  394.       $cbeg
  395.       $cass
  396.       $dass
  397.       $$work = 1
  398.     endif
  399.  
  400.   endif
  401. endm
  402.  
  403. ENDWORK macro
  404.   if $$work
  405.     $cend
  406.     $$work = 0
  407.   endif
  408. endm
  409.  
  410. $func macro p1
  411.   if $$stat
  412.     $endstatic
  413.   endif
  414.  
  415.   if $$work
  416.     ENDWORK
  417.   endif
  418.  
  419.   if $$cseg EQ 0
  420.     CODESEG
  421.   endif
  422.  
  423.   if $$lev
  424.     $err <nested CLfunc>
  425.  
  426.   else
  427.     $$lev = 2
  428.  
  429.     $entry macro
  430.       $gen <p1        PROC    FAR>
  431.     endm
  432.  
  433.     $$pb = 10
  434.     $$tb = 2
  435.  
  436.     $exit macro
  437.       $gen <p1        ENDP>
  438.     endm
  439.  
  440.   endif
  441. endm
  442.  
  443. CLfunc macro p1, p2, p3
  444.   $&p1
  445.   $func p2
  446.  
  447.   $define $$pl    <<p3>>
  448.  
  449.   ifnb <p3>
  450.     $$lev = 2
  451.  
  452.     irp $$item, <p3>
  453.       $&&$$item
  454.  
  455.     endm
  456.   endif
  457. endm
  458.  
  459. $temp macro
  460.  
  461.   if ($$lev GE 1) AND ($$lev LE 2)
  462.     $$lev = 2
  463.  
  464.   else
  465.     $err <CLlocal w/o CLfunc>
  466.  
  467.   endif
  468. endm
  469.  
  470. CLlocal macro p1
  471.   $temp
  472.  
  473.   irp $$item, <p1>
  474.     $&&$$item
  475.  
  476.   endm
  477. endm
  478.  
  479. CLcode macro
  480.  
  481.   if ($$lev GE 1) AND ($$lev LE 2)
  482.     $cbeg
  483.     $cass
  484.     $dass
  485.     $entry
  486.     $gen <        PUSH    BP>
  487.     $gen <        PUSH    SI>
  488.     $gen <        PUSH    DI>
  489.     $gen <        MOV    BP, SP>
  490.  
  491.     if $$lev EQ 2
  492.       $result macro p4
  493.     $gen <        SUB    SP, p4>
  494.       endm
  495.  
  496.       $result %$$tb
  497.       purge $result
  498.  
  499.       $getparam %$$pl
  500.  
  501.     endif
  502.  
  503.     purge $entry
  504.     $$lev = 3
  505.  
  506.   else
  507.     $err <CLcode w/o CLfunc>
  508.  
  509.   endif
  510. endm
  511.  
  512. $getparam macro p1
  513.   ifb <p1>
  514.     exitm
  515.   endif
  516.  
  517.   Ccall    _parinfo <0>
  518.   $gen <        MOV    PCOUNT, AX>
  519.   $gen <        XOR    AX, AX>
  520.  
  521.   irp $$item, <p1>
  522.     $gen <        INC    AX>
  523.     $gen <        PUSH    AX>
  524.  
  525.     $p_&&$$item
  526.  
  527.     $gen <        POP    AX>
  528.   endm
  529. endm
  530.  
  531. $chktype macro p1
  532.   $gen <        PUSH    AX>
  533.  
  534.   Ccall    _parinfo <AX>
  535.   $gen <        TEST    AX, p1>
  536.  
  537.   $gen <        POP    AX>
  538. endm
  539.  
  540. $p_char macro p1
  541.   LOCAL noparam
  542.   $gen <        MOV    WORD PTR p1, 0>
  543.   $gen <        MOV    WORD PTR p1[2], 0>
  544.   $gen <        CMP    AX, PCOUNT>
  545.   $gen <        JA    noparam>
  546.  
  547.   $chktype $$CHARACTER
  548.   $gen <        JZ    noparam>
  549.  
  550.   Ccall _parc <AX>
  551.   $gen <        MOV    WORD PTR p1, AX>
  552.   $gen <        MOV    WORD PTR p1[2], DX>
  553. noparam:
  554. endm
  555.  
  556. $p_int macro p1
  557.   LOCAL noparam
  558.   $gen <        MOV    p1, 0>
  559.   $gen <        CMP    AX, PCOUNT>
  560.   $gen <        JA    noparam>
  561.  
  562.   $chktype $$NUMERIC
  563.   $gen <        JZ    noparam>
  564.  
  565.   Ccall _parni <AX>
  566.   $gen <        MOV    p1, AX>
  567. noparam:
  568. endm
  569.  
  570. $p_long macro p1
  571.   LOCAL noparam
  572.   $gen <        MOV    WORD PTR p1, 0>
  573.   $gen <        MOV    WORD PTR p1[2], 0>
  574.   $gen <        CMP    AX, PCOUNT>
  575.   $gen <        JA    noparam>
  576.  
  577.   $chktype $$NUMERIC
  578.   $gen <        JZ    noparam>
  579.  
  580.   Ccall _parnl <AX>
  581.   $gen <        MOV    WORD PTR p1, AX>
  582.   $gen <        MOV    WORD PTR p1[2], DX>
  583. noparam:
  584. endm
  585.  
  586. $p_double macro p1
  587.   LOCAL noparam
  588.   $gen <        MOV    WORD PTR p1, 0>
  589.   $gen <        MOV    WORD PTR p1[2], 0>
  590.   $gen <        MOV    WORD PTR p1[4], 0>
  591.   $gen <        MOV    WORD PTR p1[6], 0>
  592.   $gen <        CMP    AX, PCOUNT>
  593.   $gen <        JA    noparam>
  594.  
  595.   $chktype $$NUMERIC
  596.   $gen <        JZ    noparam>
  597.  
  598.   Ccall _parnd <AX>
  599.  
  600.   $gen <        PUSH    ES>
  601.   $gen <        MOV    ES, DX>
  602.   $gen <        MOV    BX, AX>
  603.  
  604.   $gen <        MOV    AX, ES:[BX]>
  605.   $gen <        MOV    WORD PTR p1, AX>
  606.   $gen <        MOV    AX, ES:[BX + 2]>
  607.   $gen <        MOV    WORD PTR p1[2], AX>
  608.   $gen <        MOV    AX, ES:[BX + 4]>
  609.   $gen <        MOV    WORD PTR p1[4], AX>
  610.   $gen <        MOV    AX, ES:[BX + 6]>
  611.   $gen <        MOV    WORD PTR p1[6], AX>
  612.  
  613.   $gen <        POP    ES>
  614. noparam:
  615. endm
  616.  
  617. $p_log macro p1
  618.   LOCAL noparam
  619.   $gen <        MOV    p1, 0>
  620.   $gen <        CMP    AX, PCOUNT>
  621.   $gen <        JA    noparam>
  622.  
  623.   $chktype $$LOGICAL
  624.   $gen <        JZ    noparam>
  625.  
  626.   Ccall _parl <AX>
  627.   $gen <        MOV    p1, AX>
  628. noparam:
  629. endm
  630.  
  631. $p_date macro p1
  632.   LOCAL noparam
  633.   $gen <        MOV    WORD PTR p1, 0>
  634.   $gen <        MOV    WORD PTR p1[2], 0>
  635.   $gen <        CMP    AX, PCOUNT>
  636.   $gen <        JA    noparam>
  637.  
  638.   $chktype $$DATE
  639.   $gen <        JZ    noparam>
  640.  
  641.   Ccall _pards <AX>
  642.   $gen <        MOV    WORD PTR p1, AX>
  643.   $gen <        MOV    WORD PTR p1[2], DX>
  644. noparam:
  645. endm
  646.  
  647. TESTNUL macro p1
  648.   if (p1&_BYTE$) EQ 4
  649.     $gen <        PUSH    AX>
  650.     $gen <        MOV    AX, WORD PTR p1>
  651.     $gen <        OR    AX, WORD PTR p1[2]>
  652.     $gen <        POP    AX>
  653.  
  654.   else
  655.     if (p1&_BYTE$) EQ 2
  656.       $gen <        TEST    p1, 0FFFFH>
  657.  
  658.     else
  659.       if (p1&_BYTE$) EQ 1
  660.     $gen <        TEST    p1, 0FFH>
  661.  
  662.       else
  663.     $gen <        PUSH    AX>
  664.     $gen <        MOV    AX, WORD PTR p1>
  665.     $gen <        OR    AX, WORD PTR p1[2]>
  666.     $gen <        OR    AX, WORD PTR p1[4]>
  667.     $gen <        OR    AX, WORD PTR p1[6]>
  668.     $gen <        POP    AX>
  669.  
  670.       endif
  671.     endif
  672.   endif
  673. endm
  674.  
  675. $treg macro p1
  676.  
  677.   irp $$reg, <AX, BX, CX, DX, SI, DI, CS, DS, ES, SS, BP, SP>
  678.  
  679.     ifidni <p1>, <$$reg>
  680.       $$isreg = 1
  681.       exitm
  682.     endif
  683.  
  684.   endm
  685. endm
  686.  
  687. $putparam macro p1,p2
  688.   $$q = 0
  689.  
  690.   irp $$item, <p1>
  691.     $$q = $$q + 1
  692.  
  693.     if $$q EQ p2
  694.       $$isreg = 0
  695.  
  696.       $treg <$$item>
  697.       if $$isreg
  698.     $$pval = $$pval + 2
  699.     $gen <        PUSH    $$item>
  700.  
  701.       else
  702.     ifdef $$item
  703.       if ($$item&&_BYTE$) EQ 4
  704.         $$pval = $$pval + 4
  705.         $gen <        PUSH    WORD PTR $$item[2]>
  706.         $gen <        PUSH    WORD PTR $$item>
  707.  
  708.       else
  709.         if ($$item&&_BYTE$) EQ 2
  710.           $$pval = $$pval + 2
  711.           $gen <        PUSH    $$item>
  712.  
  713.         else
  714.           if ($$item&&_BYTE$) EQ 1
  715.         $$pval = $$pval + 2
  716.         $gen <        PUSH    AX>
  717.         $gen <        MOV    AL, $$item>
  718.         $gen <        MOV    AH, 0>
  719.         $gen <        PUSH    BP>
  720.         $gen <        MOV    BP, SP>
  721.         $gen <        XCHG    AX, [BP + 2]>
  722.         $gen <        POP    BP>
  723.  
  724.           else
  725.         $$pval = $$pval + 8
  726.         $gen <        PUSH    WORD PTR $$item[6]>
  727.         $gen <        PUSH    WORD PTR $$item[4]>
  728.         $gen <        PUSH    WORD PTR $$item[2]>
  729.         $gen <        PUSH    WORD PTR $$item>
  730.  
  731.           endif
  732.         endif
  733.       endif
  734.  
  735.     else
  736.       $$pval = $$pval + 2
  737.       $gen <        PUSH    AX>
  738.       $gen <        MOV    AX, $$item>
  739.       $gen <        PUSH    BP>
  740.       $gen <        MOV    BP, SP>
  741.       $gen <        XCHG    AX, [BP + 2]>
  742.       $gen <        POP    BP>
  743.  
  744.     endif
  745.       endif
  746.  
  747.       exitm
  748.  
  749.     endif
  750.   endm
  751. endm
  752.  
  753. Ccall macro p1,p2
  754.   $$pval = 0
  755.  
  756.   ifnb <p2>
  757.     $$param_count = 0
  758.  
  759.     irp $$item, <p2>
  760.       $$param_count = $$param_count + 1
  761.  
  762.     endm
  763.  
  764.     $$param = $$param_count
  765.  
  766.     rept $$param_count
  767.       $putparam <p2>,%$$param
  768.       $$param = $$param - 1
  769.  
  770.     endm
  771.   endif
  772.  
  773.   $gen <        CALL    FAR PTR p1>
  774.  
  775.   if $$pval
  776.     $gen <        ADD    SP,$$pval>
  777.  
  778.   endif
  779. endm
  780.  
  781. CLret macro p1,p2
  782.  
  783.   if $$lev EQ 3
  784.  
  785.     ifnb <p1>
  786.       $$isreg = 0
  787.  
  788.       $treg p1
  789.       if $$isreg
  790.  
  791.     ifnb <p2>
  792.       if $$rb NE 4
  793.         $err <Function return mismatch>
  794.  
  795.       else
  796.         Ccall $$rf <p2, p1>
  797.  
  798.       endif
  799.  
  800.     else
  801.       if ($$rb LT 1) OR ($$rb GT 2)
  802.         $err <Function return mismatch>
  803.  
  804.       else
  805.         Ccall $$rf <p1>
  806.  
  807.       endif
  808.     endif
  809.  
  810.       else
  811.     if (p1&_BYTE$) NE $$rb
  812.       $err <Function return mismatch>
  813.  
  814.     else
  815.       Ccall $$rf <p1>
  816.  
  817.     endif
  818.       endif
  819.  
  820.     else
  821.       if $$rb NE 0
  822.     $err <Function return mismatch>
  823.  
  824.       else
  825.     Ccall $$rf
  826.  
  827.       endif
  828.     endif
  829.  
  830.     if $$tb
  831.       $result macro p4
  832.     $gen <        ADD    SP, p4>
  833.       endm
  834.  
  835.       $result %$$tb
  836.       purge $result
  837.  
  838.     endif
  839.  
  840.     $gen <        POP    DI>
  841.     $gen <        POP    SI>
  842.     $gen <        POP    BP>
  843.     $gen <        RET>
  844.     $exit
  845.     purge $exit
  846.     $cend
  847.  
  848.   else
  849.     $err <Return w/o CLfunc/CLcode>
  850.  
  851.   endif
  852.  
  853.   $$lev = 0
  854. endm
  855.  
  856. $decl macro p1, p2, p3
  857.  
  858.   if $$lev EQ 1
  859.     $result macro p4
  860.       $gen <p1        EQU    [p3 PTR [BP + p4]]>
  861.     endm
  862.  
  863.     $result %$$pb
  864.     purge $result
  865.  
  866.     $$pb = $$pb + p2
  867.  
  868.   else
  869.     if $$lev EQ 2
  870.       $$tb = $$tb + p2
  871.  
  872.       $result macro p4
  873.         $gen <p1        EQU    [p3 PTR [BP - p4]]>
  874.       endm
  875.  
  876.       $result %$$tb
  877.       purge $result
  878.  
  879.     else
  880.       $err <decl w/o CLfunc>
  881.  
  882.     endif
  883.   endif
  884.  
  885.   ifidni <p3>, <BYTE>
  886.     $gen <p1&_BYTE$    =    1>
  887.   else
  888.     $gen <p1&_BYTE$    =    p2>
  889.   endif
  890.  
  891. endm
  892.  
  893. $void macro
  894.   $$rb = 0
  895.   $define $$rf    <<_ret>>
  896. endm
  897.  
  898. $char macro p1
  899.   ifnb <p1>
  900.     $decl p1, 4, DWORD
  901.   else
  902.     $$rb = 4
  903.     $define $$rf    <<_retc>>
  904.   endif
  905. endm
  906.  
  907. $int macro p1
  908.   ifnb <p1>
  909.     $decl p1, 2, WORD
  910.   else
  911.     $$rb = 2
  912.     $define $$rf    <<_retni>>
  913.   endif
  914. endm
  915.  
  916. $long macro p1
  917.   ifnb <p1>
  918.     $decl p1, 4, DWORD
  919.   else
  920.     $$rb = 4
  921.     $define $$rf    <<_retnl>>
  922.   endif
  923. endm
  924.  
  925. $double macro p1
  926.   ifnb <p1>
  927.     $decl p1, 8, QWORD
  928.   else
  929.     $$rb = 8
  930.     $define $$rf    <<_retnd>>
  931.   endif
  932. endm
  933.  
  934. $log macro p1
  935.   ifnb <p1>
  936.     $decl p1, 2, WORD
  937.   else
  938.     $$rb = 2
  939.     $define $$rf    <<_retl>>
  940.   endif
  941. endm
  942.  
  943. $date macro p1
  944.   ifnb <p1>
  945.     $decl p1, 4, DWORD
  946.   else
  947.     $$rb = 4
  948.     $define $$rf    <<_retds>>
  949.   endif
  950. endm
  951.  
  952. CLpublic macro p1
  953.  
  954.   irp $$item, <p1>
  955.     $gen <        PUBLIC    $$item>
  956.  
  957.   endm
  958. endm
  959.  
  960. Cglobal macro p1
  961.  
  962.   irp $$item, <p1>
  963.     $gen <        PUBLIC    _&&$$item>
  964.     $gen <$$item    EQU    _&&$$item>
  965.     $gen <$$item&&_PUBLIC$    =    1>
  966.  
  967.   endm
  968. endm
  969.  
  970. CLlabel macro p1
  971.  
  972.   irp $$item, <p1>
  973.     $l_&&$$item
  974.  
  975.   endm
  976. endm
  977.  
  978. $l_byte macro p1
  979.   $gen <p1&_BYTE$    =    1>
  980.  
  981.   irp $$item, <p1>
  982.     ifdef $$item&&_PUBLIC$
  983.       $gen <_&&$$item        LABEL    BYTE>
  984.  
  985.     else
  986.       $gen <$$item        LABEL    BYTE>
  987.  
  988.     endif
  989.  
  990.   endm
  991. endm
  992.  
  993. $l_string macro p1
  994.   $l_byte p1
  995. endm
  996.  
  997. $l_int macro p1
  998.   $gen <p1&_BYTE$    =    2>
  999.  
  1000.   irp $$item, <p1>
  1001.     ifdef $$item&&_PUBLIC$
  1002.       $gen <_&&$$item        LABEL    WORD>
  1003.  
  1004.     else
  1005.       $gen <$$item        LABEL    WORD>
  1006.  
  1007.     endif
  1008.  
  1009.   endm
  1010. endm
  1011.  
  1012. $l_log macro p1
  1013.   $l_int p1
  1014. endm
  1015.  
  1016. $l_long macro p1
  1017.   $gen <p1&_BYTE$    =    4>
  1018.  
  1019.   irp $$item, <p1>
  1020.     ifdef $$item&&_PUBLIC$
  1021.       $gen <_&&$$item        LABEL    DWORD>
  1022.  
  1023.     else
  1024.       $gen <$$item        LABEL    DWORD>
  1025.  
  1026.     endif
  1027.  
  1028.   endm
  1029. endm
  1030.  
  1031. $l_double macro p1
  1032.   $gen <p1&_BYTE$    =    8>
  1033.  
  1034.   irp $$item, <p1>
  1035.     ifdef $$item&&_PUBLIC$
  1036.       $gen <_&&$$item        LABEL    QWORD>
  1037.  
  1038.     else
  1039.       $gen <$$item        LABEL    QWORD>
  1040.  
  1041.     endif
  1042.  
  1043.   endm
  1044. endm
  1045.  
  1046. $l_cptr macro p1
  1047.   $gen <p1&_BYTE$    =    4>
  1048.  
  1049.   irp $$item, <p1>
  1050.     ifdef $$item&&_PUBLIC$
  1051.       $gen <_&&$$item        LABEL    DWORD>
  1052.  
  1053.     else
  1054.       $gen <$$item        LABEL    DWORD>
  1055.  
  1056.     endif
  1057.   endm
  1058.  
  1059.   $gen <p1&_OFF        EQU    WORD PTR p1>
  1060.   $gen <p1&_SEG        EQU    WORD PTR p1[2]>
  1061.   $gen <p1&_OFF_BYTE$        =    2>
  1062.   $gen <p1&_SEG_BYTE$        =    2>
  1063.  
  1064. endm
  1065.  
  1066. $import macro p1, p2
  1067.   if $$stat
  1068.     $dend
  1069.   endif
  1070.  
  1071.   if $$lev EQ 3
  1072.     $cend
  1073.   endif
  1074.  
  1075.   $gen <        EXTRN    _&p1:p2>
  1076.   $gen <p1        EQU    _&p1>
  1077.  
  1078.   if $$stat
  1079.     $dbeg
  1080.   endif
  1081.  
  1082.   if $$lev EQ 3
  1083.     $cbeg
  1084.   endif
  1085.  
  1086. endm
  1087.  
  1088. $x_byte macro p1
  1089.   $gen <p1&_BYTE$    =    2>
  1090.  
  1091.   $import p1 WORD
  1092. endm
  1093.  
  1094. $x_int macro p1
  1095.   $gen <p1&_BYTE$    =    2>
  1096.  
  1097.   $import p1 WORD
  1098. endm
  1099.  
  1100. $x_log macro p1
  1101.   $x_int p1
  1102. endm
  1103.  
  1104. $x_long macro p1
  1105.   $gen <p1&_BYTE$    =    4>
  1106.  
  1107.   $import p1 DWORD
  1108. endm
  1109.  
  1110. $x_double macro p1
  1111.   $gen <p1&_BYTE$    =    8>
  1112.  
  1113.   $import p1 QWORD
  1114. endm
  1115.  
  1116. $x_cptr macro p1
  1117.   $gen <p1&_BYTE$    =    4>
  1118.  
  1119.   $import p1 DWORD
  1120. endm
  1121.  
  1122. $x_far macro p1
  1123.   $import p1 FAR
  1124. endm
  1125.  
  1126.  
  1127. .LIST
  1128.  
  1129.  
  1130.