home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 September / PCWK996.iso / polskie / orhmet / dfdisk / clipface / pobierz.c < prev    next >
Text File  |  1996-06-26  |  4KB  |  291 lines
  1. #include <extend.h>
  2. #include "../rlibc/rlibc.h"
  3.  
  4. CLIPPER dfSendPort( void )
  5. {
  6.     if (PCOUNT<2)
  7.     {
  8.         _retni(R4);
  9.         return;
  10.     }
  11.     _retni(sendport( _parni(1), _parc(2) ));
  12. }
  13.  
  14. CLIPPER dfRecvPort( void )
  15. {
  16.     if (PCOUNT<2)
  17.     {
  18.         _retni(R4);
  19.         return;
  20.     }
  21.     _retni(recvport( _parni(1), _parc(2) ));
  22. }
  23.  
  24. CLIPPER dfGetTOut ( void )
  25. {
  26.     _retni(DFGetTOut());
  27. }
  28.  
  29.  
  30. CLIPPER dfGetCode ( void )
  31. {
  32.     int wynik;
  33.     char bufor[4];
  34.  
  35.     if (PCOUNT<1)
  36.     {
  37.         _retni(R4);
  38.         return;
  39.     }
  40.     wynik=DFGetCode(bufor);
  41.     _storc(bufor, 1);
  42.     _retni(wynik);
  43. }
  44.  
  45. CLIPPER dfGetVatR ( void )
  46. {
  47.     int wynik;
  48.     char bufor[9];
  49.  
  50.     if (PCOUNT<1)
  51.     {
  52.         _retni(R4);
  53.         return;
  54.     }
  55.     wynik=DFGetVatRates(bufor);
  56.     _storc(bufor, 1);
  57.     _retni(wynik);
  58. }
  59.  
  60. CLIPPER dfGetVR2 ( void )
  61. {
  62.     int wynik;
  63.     char bufor[25];
  64.  
  65.     if (PCOUNT<1)
  66.     {
  67.         _retni(R4);
  68.         return;
  69.     }
  70.     wynik=DFGetVatRates2(bufor);
  71.     _storc(bufor, 1);
  72.     _retni(wynik);
  73. }
  74.  
  75. CLIPPER dfTowInfo ( )
  76. {
  77.     int wynik;
  78.     char bufor[6];
  79.  
  80.     if (PCOUNT<2)
  81.     {
  82.         _retni(R4);
  83.         return;
  84.     }
  85.     if (_parinfo(1)!=CHARACTER)
  86.     {
  87.         _retni(R4);
  88.         return;
  89.     }
  90.     wynik=DFTowarInfo(_parc(1), bufor);
  91.     _storc(bufor, 2);
  92.     _retni(wynik);
  93. }
  94.  
  95. CLIPPER dfGetTTime ( void )
  96. {
  97.     int wynik;
  98.     char bufor[3];
  99.  
  100.     if (PCOUNT<1)
  101.     {
  102.         _retni(R4);
  103.         return;
  104.     }
  105.     wynik=DFGetTTime(bufor);
  106.     _storc(bufor, 1);
  107.     _retni(wynik);
  108. }
  109.  
  110. CLIPPER dfGetSym ( void )
  111. {
  112.     int wynik;
  113.     char bufor[6];
  114.  
  115.     if (PCOUNT<1)
  116.     {
  117.         _retni(R4);
  118.         return;
  119.     }
  120.     wynik=DFGetSymbol(bufor);
  121.     _storc(bufor, 1);
  122.     _retni(wynik);
  123. }
  124.  
  125. CLIPPER dfGetHead ( void )
  126. {
  127.     int wynik;
  128.     char bufor[145];
  129.  
  130.     if (PCOUNT<1)
  131.     {
  132.         _retni(R4);
  133.         return;
  134.     }
  135.     wynik=DFGetHeader(bufor);
  136.     _storc(bufor, 1);
  137.     _retni(wynik);
  138. }
  139.  
  140. CLIPPER dfGetFoot ( void )
  141. {
  142.     int wynik;
  143.     char bufor[145];
  144.  
  145.     if (PCOUNT<1)
  146.     {
  147.         _retni(R4);
  148.         return;
  149.     }
  150.     wynik=DFGetFooter(bufor);
  151.     _storc(bufor, 1);
  152.     _retni(wynik);
  153. }
  154.  
  155. CLIPPER dfGetTimDa ( void )
  156. {
  157.     int wynik;
  158.     char data[7];
  159.     char czas[5];
  160.  
  161.     if (PCOUNT<2)
  162.     {
  163.         _retni(R4);
  164.         return;
  165.     }
  166.     wynik=DFGetTimDat(data, czas);
  167.     _storc(data, 1);
  168.     _storc(czas, 2);
  169.     _retni(wynik);
  170. }
  171.  
  172. CLIPPER dfGetS ( void )
  173. {
  174.     int wynik;
  175.     char bufor[3];
  176.  
  177.     if (PCOUNT<1)
  178.     {
  179.         _retni(R4);
  180.         return;
  181.     }
  182.     wynik=DFGetSerwis(bufor);
  183.     _storc(bufor, 1);
  184.     _retni(wynik);
  185. }
  186.  
  187. CLIPPER dfGetTotal ( void )
  188. {
  189.     int wynik;
  190.     char *data="           ";
  191.     char *numrap="       ";
  192.     char *sprzedA="          ";
  193.     char *sprzedB="          ";
  194.     char *sprzedC="          ";
  195.     char *sprzedD="          ";
  196.     char *sprzedE="          ";
  197.     char *sprzedF="          ";
  198.     char *sprzedZW="          ";
  199.     char *ilparfisk="       ";
  200.  
  201.     if (PCOUNT<10)
  202.     {
  203.         _retni(R4);
  204.         return;
  205.     }
  206.  
  207.     wynik=DFGetTotal( data, numrap, sprzedA, sprzedB, sprzedC, sprzedD,
  208.                          sprzedE, sprzedF, sprzedZW, ilparfisk);
  209.     _storc(data, 1);
  210.     _storc(numrap, 2);
  211.     _storc(sprzedA, 3);
  212.     _storc(sprzedB, 4);
  213.     _storc(sprzedC, 5);
  214.     _storc(sprzedD, 6);
  215.     _storc(sprzedE, 7);
  216.     _storc(sprzedF, 8);
  217.     _storc(sprzedZW, 9);
  218.     _storc(ilparfisk, 10);
  219.     _retni(wynik);
  220. }
  221.  
  222. CLIPPER dfGetNUNIP ( void )
  223. {
  224.     int wynik;
  225.     char *nu="          ";
  226.     char *nip="             ";
  227.  
  228.     if (PCOUNT<2)
  229.     {
  230.         _retni(R4);
  231.         return;
  232.     }
  233.  
  234.     wynik=DFGetNU_NIP( nu, nip );
  235.     _storc(nu, 1);
  236.     _storc(nip, 2);
  237.     _retni(wynik);
  238. }
  239.  
  240. CLIPPER dfGetNumRD ( void )
  241. {
  242.     int wynik;
  243.     char *data="        ";
  244.     char *numer="     ";
  245.  
  246.     if (PCOUNT<2)
  247.     {
  248.         _retni(R4);
  249.         return;
  250.     }
  251.  
  252.     wynik=DFGetNumRapDob( data, numer );
  253.     _storc(data, 1);
  254.     _storc(numer, 2);
  255.     _retni(wynik);
  256. }
  257.  
  258. CLIPPER dfGetIlZer ( void )
  259. {
  260.     int wynik;
  261.     char *il="   ";
  262.     char *zm="  ";
  263.  
  264.     if (PCOUNT<1)
  265.     {
  266.         _retni(R4);
  267.         return;
  268.     }
  269.  
  270.     wynik=DFGetIlZerRAM( il, zm );
  271.     _storc(il, 1);
  272.     _storc(zm, 2);
  273.     _retni(wynik);
  274. }
  275.  
  276. CLIPPER dfGetOnLin ( void )
  277. {
  278.     int wynik;
  279.     char bufor[2];
  280.  
  281.     if (PCOUNT<1)
  282.     {
  283.         _retni(R4);
  284.         return;
  285.     }
  286.     wynik=DFGetOnLine(bufor);
  287.     _storc(bufor, 1);
  288.     _retni(wynik);
  289. }
  290.  
  291.