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