home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 9 / 09.iso / e / e065 / 2.ddi / UIO_COMP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-28  |  6.5 KB  |  342 lines
  1. /**********************************************************************/
  2. /*                                                                    */
  3. /*    uio_comp.c - provides compatibilty with old style UserIO code   */
  4. /*    Author: John C. Fairman           October 8, 1990               */
  5. /*    Copyright 1990 by NeuralWare Inc.                               */
  6. /*                                                                    */
  7. /*    $Author   :  $                                                  */
  8. /*    $Date     :  $                                                  */
  9. /*    $Source   :  $                                                  */
  10. /*    $Revision :  $                                                  */
  11. /*    $Log      :  $                                                  */
  12. /*                                                                    */
  13. /**********************************************************************/
  14.  
  15. #define UIO_SERVER             1
  16. #define SERVER_EMULATOR_FILE   1
  17. #define HOME_FOR_COMPAT_DATA   1
  18. #include "userutl.h"
  19. #include "uio_strc.h"
  20. #include "uio_reqs.pro"
  21. #include "uio_cmds.pro"
  22.  
  23. int UsrIO();
  24.  
  25. /*********************************************************************/
  26. /*                                                                   */
  27. /* Functions neccessary for handling the User I/O package itself.    */
  28. /*                                                                   */
  29. /*********************************************************************/
  30.  
  31. /* FUNCTION */
  32. NINT UIO_Init(file)
  33. TEXT *file;
  34. {
  35.   NINT ret_val = UIO_OK;
  36.  
  37.   return(ret_val);
  38. }
  39.  
  40.  
  41. /* */
  42. /* FUNCTION */
  43. NINT UIO_Term(process)
  44. NINT process;
  45. {
  46.   NINT ret_val = UIO_OK;
  47.  
  48.   IOCOUNT   = 0;
  49.   IOLAYER   = 0;
  50.   IOREQCDE  = RQ_TERM;
  51.   UsrIO();
  52.   ret_val   = IORTNCDE;
  53.  
  54.   return(ret_val);
  55. }
  56.  
  57.  
  58. /* FUNCTION */
  59. NINT UIO_Attention()
  60. {
  61.   NINT ret_val = UIO_OK;
  62.  
  63.   IOCOUNT   = 0;
  64.   IOLAYER   = 0;
  65.   IOREQCDE  = RQ_ATTENTION;
  66.   UsrIO();
  67.   ret_val   = IORTNCDE;
  68.  
  69.   return(ret_val);
  70. }
  71.  
  72.  
  73. /**************************************************************/
  74. /*                                                            */
  75. /*  Functions necessary for handling a learning session.      */
  76. /*                                                            */
  77. /**************************************************************/
  78.  
  79. /* FUNCTION */
  80. NINT UIO_Learn_Start()
  81. {
  82.   NINT ret_val = UIO_OK;
  83.  
  84.   IOCOUNT   = 0;
  85.   IOLAYER   = 0;
  86.   IOREQCDE  = RQ_LSTART;
  87.   UsrIO();
  88.   ret_val   = IORTNCDE;
  89.  
  90.   return(ret_val);
  91. }
  92.  
  93.  
  94. /* */
  95. /* FUNCTION */
  96. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  97. NINT  LayN;
  98. NINT  nPEs;
  99. SREAL *Datap;
  100. {
  101.   NINT ret_val = UIO_OK;
  102.  
  103.   IODATA    = Datap;
  104.   IOCOUNT   = nPEs;
  105.   IOLAYER   = LayN;
  106.   IOREQCDE  = RQ_LEARNIN;
  107.   UsrIO();
  108.   ret_val   = IORTNCDE;
  109.  
  110.   return(ret_val);
  111. }
  112.  
  113.  
  114. /* FUNCTION */
  115. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  116. NINT  LayN;
  117. NINT  nPEs;
  118. SREAL *Datap;
  119. {
  120.   NINT ret_val = UIO_OK;
  121.  
  122.   IODATA    = Datap;
  123.   IOCOUNT   = nPEs;
  124.   IOLAYER   = LayN;
  125.   IOREQCDE  = RQ_LEARNOUT;
  126.   UsrIO();
  127.   ret_val   = IORTNCDE;
  128.  
  129.   return(ret_val);
  130. }
  131.  
  132.  
  133. /* FUNCTION */
  134. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  135. NINT  LayN;
  136. NINT  nPEs;
  137. SREAL *Datap;
  138. {
  139.   NINT ret_val = UIO_OK;
  140.  
  141.   IODATA    = Datap;
  142.   IOCOUNT   = nPEs;
  143.   IOLAYER   = LayN;
  144.   IOREQCDE  = RQ_LEARNRSLT;
  145.   UsrIO();
  146.   ret_val   = IORTNCDE;
  147.  
  148.   return(ret_val);
  149. }
  150.  
  151.  
  152. /* */
  153. /* FUNCTION */
  154. NINT UIO_Learn_End()
  155. {
  156.   NINT ret_val = UIO_OK;
  157.  
  158.   IOCOUNT   = 0;
  159.   IOLAYER   = 0;
  160.   IOREQCDE  = RQ_LEND;
  161.   UsrIO();
  162.   ret_val   = IORTNCDE;
  163.  
  164.   return(ret_val);
  165. }
  166.  
  167.  
  168. /*******************************************************************/
  169. /*                                                                 */
  170. /*  Functions necessary for handling a recall or testing session.  */
  171. /*                                                                 */
  172. /*******************************************************************/
  173.  
  174. /* FUNCTION */
  175. NINT UIO_Recall_Start()
  176. {
  177.   NINT ret_val = UIO_OK;
  178.  
  179.   IOCOUNT   = 0;
  180.   IOLAYER   = 0;
  181.   IOREQCDE  = RQ_RSTART;
  182.   UsrIO();
  183.   ret_val   = IORTNCDE;
  184.  
  185.   return(ret_val);
  186. }
  187.  
  188.  
  189. /* FUNCTION */
  190. NINT UIO_Read(LayN, nPEs, Datap)
  191. NINT  LayN;
  192. NINT  nPEs;
  193. SREAL *Datap;
  194. {
  195.   NINT ret_val = UIO_OK;
  196.  
  197.   IODATA    = Datap;
  198.   IOCOUNT   = nPEs;
  199.   IOLAYER   = LayN;
  200.   IOREQCDE  = RQ_READ;
  201.   UsrIO();
  202.   ret_val   = IORTNCDE;
  203.  
  204.   return(ret_val);
  205. }
  206.  
  207.  
  208. /* */
  209. /* FUNCTION */
  210. NINT UIO_Write(LayN, nPEs, Datap)
  211. NINT  LayN;
  212. NINT  nPEs;
  213. SREAL *Datap;
  214. {
  215.   NINT ret_val = UIO_OK;
  216.  
  217.   IODATA    = Datap;
  218.   IOCOUNT   = nPEs;
  219.   IOLAYER   = LayN;
  220.   IOREQCDE  = RQ_WRITE;
  221.   UsrIO();
  222.   ret_val   = IORTNCDE;
  223.  
  224.   return(ret_val);
  225. }
  226.  
  227.  
  228. /* FUNCTION */
  229. NINT UIO_Write_Step(LayN, nPEs, Datap)
  230. NINT  LayN;
  231. NINT  nPEs;
  232. SREAL *Datap;
  233. {
  234.   NINT ret_val = UIO_OK;
  235.  
  236.   IODATA    = Datap;
  237.   IOCOUNT   = nPEs;
  238.   IOLAYER   = LayN;
  239.   IOREQCDE  = RQ_WRSTEP;
  240.   UsrIO();
  241.   ret_val   = IORTNCDE;
  242.  
  243.   return(ret_val);
  244. }
  245.  
  246.  
  247. /* FUNCTION */
  248. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  249. NINT  LayN;
  250. NINT  nPEs;
  251. SREAL *Datap;
  252. {
  253.   NINT ret_val = UIO_OK;
  254.  
  255.   IODATA    = Datap;
  256.   IOCOUNT   = nPEs;
  257.   IOLAYER   = LayN;
  258.   IOREQCDE  = RQ_RCLTST;
  259.   UsrIO();
  260.   ret_val   = IORTNCDE;
  261.  
  262.   return(ret_val);
  263. }
  264.  
  265. /* */
  266. /* FUNCTION */
  267. NINT UIO_Recall_End()
  268. {
  269.   NINT ret_val = UIO_OK;
  270.  
  271.   IOCOUNT   = 0;
  272.   IOLAYER   = 0;
  273.   IOREQCDE  = RQ_REND;
  274.   UsrIO();
  275.   ret_val   = IORTNCDE;
  276.  
  277.   return(ret_val);
  278. }
  279.  
  280.  
  281. /*****************************************************/
  282. /*                                                   */
  283. /*  Other miscelaneous functions.                    */
  284. /*                                                   */
  285. /*****************************************************/
  286.  
  287. /* FUNCTION */
  288. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  289. NINT  Instrument_id;
  290. NINT  nDataElems;
  291. SREAL *DataElemp;
  292. {
  293.   NINT ret_val = UIO_OK;
  294.  
  295.   IODATA    = DataElemp;
  296.   IOCOUNT   = nDataElems;
  297.   IOLAYER   = Instrument_id;
  298.   IOREQCDE  = RQ_INSTRUM;
  299.   UsrIO();
  300.   ret_val   = IORTNCDE;
  301.  
  302.   return(ret_val);
  303. }
  304.  
  305.  
  306. /* FUNCTION */
  307. NINT UIO_Rewind()
  308. {
  309.   NINT ret_val = UIO_OK;
  310.  
  311.   IOCOUNT   = 0;
  312.   IOLAYER   = 0;
  313.   IOREQCDE  = RQ_REWIND;
  314.   UsrIO();
  315.   ret_val   = IORTNCDE;
  316.  
  317.   return(ret_val);
  318. }
  319.  
  320.  
  321. /* */
  322. /* FUNCTION */
  323. NINT UIO_Explain(LayN, nPEs, Datap)
  324. NINT  LayN;
  325. NINT  nPEs;
  326. SREAL *Datap;
  327. {
  328.   NINT ret_val = UIO_OK;
  329.  
  330.   IODATA    = Datap;
  331.   IOCOUNT   = nPEs;
  332.   IOLAYER   = LayN;
  333.   IOREQCDE  = RQ_EXPLAIN;
  334.   UsrIO();
  335.   ret_val   = IORTNCDE;
  336.  
  337.   return(ret_val);
  338. }
  339.  
  340.  
  341.  
  342.