home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 9 / 09.iso / e / e065 / 4.ddi / UCTLIO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-28  |  6.5 KB  |  313 lines
  1. /*******************************************************************/
  2. /*                                                                 */
  3. /*    uctlio.c  - Sample User IO control program showing format of */
  4. /*                 all commands from NeuralWorks.                  */
  5. /*                                                                 */
  6. /*    Author: John C. Fairman           August 31, 1990            */
  7. /*    Copyright 1990 by NeuralWare Inc.                            */
  8. /*                                                                 */
  9. /*    $Author   :  $                                               */
  10. /*    $Date     :  $                                               */
  11. /*    $Source   :  $                                               */
  12. /*    $Revision :  $                                               */
  13. /*    $Log      :  $                                               */
  14. /*                                                                 */
  15. /*******************************************************************/
  16.  
  17. #define UIO_SERVER             1
  18. #define SERVER_EMULATOR_FILE   1
  19. #define SKIP_COMPAT_DATA       1
  20. #include "userutl.h"
  21. #include "uio_strc.h"
  22. #include "uio_tran.h"
  23. #include "uio_reqs.pro"
  24. #include "uio_cmds.pro"
  25.  
  26. #ifdef MAC
  27. #include "macuio.redef"
  28. #endif
  29.  
  30. /*******************************************************************/
  31. /*                                                                 */
  32. /* Functions necessary for handling the User I/O package itself.   */
  33. /*                                                                 */
  34. /*******************************************************************/
  35.  
  36. /* FUNCTION */
  37. NINT UIO_Init(file)
  38. TEXT *file;
  39. {
  40.   NINT ret_val = UIO_OK;
  41.  
  42.  
  43.   /* USER TO PLACE CODE HERE */
  44.  
  45.   return(ret_val);
  46. }
  47.  
  48.  
  49. /* */
  50. /* FUNCTION */
  51. NINT UIO_Term(process)
  52. NINT process;
  53. {
  54.   PutStr( "Control: bye bye\n" );
  55.  
  56.   return(UIO_OK);
  57. }
  58.  
  59.  
  60. /* FUNCTION */
  61. NINT UIO_Attention()
  62. {
  63.         int   wx;       /* work index */
  64.         char  buf[100];       /* work buffer */
  65.  
  66.   if ( (wx = ug_loadnet( "samplec" )) != 0 ) {
  67.       sprintf( buf, "could not load samplec, rc = %d", wx );
  68.       PutStr( buf );
  69.       GetStr();
  70.       return(UIO_OK);
  71.   }
  72.  
  73.   ug_learn( 100l );   /* learn a while */
  74.   ug_msgio( &buf[0], sizeof(buf), 0 );
  75.   PutStr( buf );      /* tell what User I/O did */
  76.   PutStr( "\n" );
  77.   ug_recall( 0l );    /* recall all */
  78.   ug_msgio( &buf[0], sizeof(buf), 0 );
  79.   PutStr( buf );      /* tell what User I/O did */
  80. #if 0
  81.   PutStr( "\n" );
  82. #endif
  83.   GetStr();
  84.  
  85.   return(UIO_OK);
  86. }
  87.  
  88. /******************************************************************/
  89. /*                                                                */
  90. /* In a User Control program only needs the following functions   */
  91. /* to avoid link errors. You do not need to provide code for any  */
  92. /* of them.                                                       */
  93. /*                                                                */
  94. /******************************************************************/
  95.  
  96. /*******************************************************************/
  97. /*                                                                 */
  98. /*  Functions necessary for handling a learning session.           */
  99. /*                                                                 */
  100. /*******************************************************************/
  101.  
  102. /* FUNCTION */
  103. NINT UIO_Learn_Start()
  104. {
  105.   NINT ret_val = UIO_OK;
  106.  
  107.  
  108.   /* USER TO PLACE CODE HERE */
  109.  
  110.   return(ret_val);
  111. }
  112.  
  113.  
  114. /* */
  115. /* FUNCTION */
  116. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  117. NINT  LayN;
  118. NINT  nPEs;
  119. SREAL *Datap;
  120. {
  121.   NINT ret_val = UIO_OK;
  122.  
  123.  
  124.   /* USER TO PLACE CODE HERE */
  125.  
  126.   return(ret_val);
  127. }
  128.  
  129.  
  130. /* FUNCTION */
  131. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  132. NINT  LayN;
  133. NINT  nPEs;
  134. SREAL *Datap;
  135. {
  136.   NINT ret_val = UIO_OK;
  137.  
  138.  
  139.   /* USER TO PLACE CODE HERE */
  140.  
  141.   return(ret_val);
  142. }
  143.  
  144.  
  145. /* */
  146. /* FUNCTION */
  147. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  148. NINT  LayN;
  149. NINT  nPEs;
  150. SREAL *Datap;
  151. {
  152.   NINT ret_val = UIO_OK;
  153.  
  154.  
  155.   /* USER TO PLACE CODE HERE */
  156.  
  157.   return(ret_val);
  158. }
  159.  
  160.  
  161. /* FUNCTION */
  162. NINT UIO_Learn_End()
  163. {
  164.   NINT ret_val = UIO_OK;
  165.  
  166.  
  167.   /* USER TO PLACE CODE HERE */
  168.  
  169.   return(ret_val);
  170. }
  171.  
  172.  
  173. /* */
  174. /*******************************************************************/
  175. /*                                                                 */
  176. /*  Functions necessary for handling a recall or testing session.  */
  177. /*                                                                 */
  178. /*******************************************************************/
  179.  
  180. /* FUNCTION */
  181. NINT UIO_Recall_Start()
  182. {
  183.   NINT ret_val = UIO_OK;
  184.  
  185.  
  186.   /* USER TO PLACE CODE HERE */
  187.  
  188.   return(ret_val);
  189. }
  190.  
  191.  
  192. /* FUNCTION */
  193. NINT UIO_Read(LayN, nPEs, Datap)
  194. NINT  LayN;
  195. NINT  nPEs;
  196. SREAL *Datap;
  197. {
  198.   NINT ret_val = UIO_OK;
  199.  
  200.  
  201.   /* USER TO PLACE CODE HERE */
  202.  
  203.   return(ret_val);
  204. }
  205.  
  206.  
  207. /* */
  208. /* FUNCTION */
  209. NINT UIO_Write(LayN, nPEs, Datap)
  210. NINT  LayN;
  211. NINT  nPEs;
  212. SREAL *Datap;
  213. {
  214.   NINT ret_val = UIO_OK;
  215.  
  216.  
  217.   /* USER TO PLACE CODE HERE */
  218.  
  219.   return(ret_val);
  220. }
  221.  
  222.  
  223. /* FUNCTION */
  224. NINT UIO_Write_Step(LayN, nPEs, Datap)
  225. NINT  LayN;
  226. NINT  nPEs;
  227. SREAL *Datap;
  228. {
  229.   NINT ret_val = UIO_OK;
  230.  
  231.  
  232.   /* USER TO PLACE CODE HERE */
  233.  
  234.   return(ret_val);
  235. }
  236.  
  237.  
  238. /* */
  239. /* FUNCTION */
  240. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  241. NINT  LayN;
  242. NINT  nPEs;
  243. SREAL *Datap;
  244. {
  245.   NINT ret_val = UIO_OK;
  246.  
  247.  
  248.   /* USER TO PLACE CODE HERE */
  249.  
  250.   return(ret_val);
  251. }
  252.  
  253. /* FUNCTION */
  254. NINT UIO_Recall_End()
  255. {
  256.   NINT ret_val = UIO_OK;
  257.  
  258.  
  259.   /* USER TO PLACE CODE HERE */
  260.  
  261.   return(ret_val);
  262. }
  263.  
  264.  
  265. /* */
  266. /*******************************************************************/
  267. /*                                                                 */
  268. /*  Other miscelaneous functions.                                  */
  269. /*                                                                 */
  270. /*******************************************************************/
  271.  
  272. /* FUNCTION */
  273. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  274. NINT  Instrument_id;
  275. NINT  nDataElems;
  276. SREAL *DataElemp;
  277. {
  278.   NINT ret_val = UIO_OK;
  279.  
  280.  
  281.   /* USER TO PLACE CODE HERE */
  282.  
  283.   return(ret_val);
  284. }
  285.  
  286.  
  287. /* FUNCTION */
  288. NINT UIO_Rewind()
  289. {
  290.   NINT ret_val = UIO_OK;
  291.  
  292.  
  293.   /* USER TO PLACE CODE HERE */
  294.  
  295.   return(ret_val);
  296. }
  297.  
  298.  
  299. /* */
  300. /* FUNCTION */
  301. NINT UIO_Explain(LayN, nPEs, Datap)
  302. NINT  LayN;
  303. NINT  nPEs;
  304. SREAL *Datap;
  305. {
  306.   NINT ret_val = UIO_OK;
  307.  
  308.  
  309.   /* USER TO PLACE CODE HERE */
  310.  
  311.   return(ret_val);
  312. }
  313.