home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 9 / 09.iso / e / e065 / 1.ddi / USERIO.C < prev   
Encoding:
C/C++ Source or Header  |  1991-08-28  |  6.5 KB  |  316 lines
  1. /*******************************************************************/
  2. /*                                                                 */
  3. /*    userio.c -   Sample User I/O program         */
  4. /*                                                                 */
  5. /*    Author: John C. Fairman           August 31, 1990            */
  6. /*    Copyright 1990 by NeuralWare Inc.                            */
  7. /*                                                                 */
  8. /*    $Author   :  $                                               */
  9. /*    $Date     :  $                                               */
  10. /*    $Source   :  $                                               */
  11. /*    $Revision :  $                                               */
  12. /*    $Log      :  $                                               */
  13. /*                                                                 */
  14. /*******************************************************************/
  15.  
  16. #define UIO_SERVER             1
  17. #define SERVER_EMULATOR_FILE   1
  18. #define SKIP_COMPAT_DATA       1
  19. #include "userutl.h"
  20. #include "uio_strc.h"
  21. #include "uio_tran.h"
  22. #include "uio_reqs.pro"
  23. #include "uio_cmds.pro"
  24.  
  25. #ifdef MAC
  26. #include "macuio.redef"
  27. #endif
  28.  
  29. /*******************************************************************/
  30. /*                                                                 */
  31. /* Functions necessary for handling the User I/O package itself.   */
  32. /*                                                                 */
  33. /*******************************************************************/
  34.  
  35. /*ARGSUSED */
  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. /*ARGSUSED*/
  51. /* FUNCTION */
  52. NINT UIO_Term(process)
  53. NINT process;
  54. {
  55.   PutStr( "bye bye\n" );
  56.  
  57.   return(UIO_OK);
  58. }
  59.  
  60.  
  61. /* FUNCTION */
  62. NINT UIO_Attention()
  63. {
  64.   NINT ret_val = UIO_OK;
  65.  
  66.  
  67.   /* USER TO PLACE CODE HERE */
  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.  
  85.   /* USER TO PLACE CODE HERE */
  86.  
  87.   return(ret_val);
  88. }
  89.  
  90.  
  91. /* */
  92. /*ARGSUSED*/
  93. /* FUNCTION */
  94. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  95. NINT  LayN;
  96. NINT  nPEs;
  97. SREAL *Datap;
  98. {
  99.         char *sp;       /* string pointer */
  100.         int   wx;       /* work index */
  101.  
  102.   NINT ret_val = UIO_OK;
  103.  
  104.   PutStr( "Enter Two Digits (ex: 00) as input or 'E' End XOR: " );
  105.   sp = GetStr();
  106.  
  107.   /* Terminate learning if user types 'E' */
  108.   if ( *sp == 'e' || *sp == 'E' ) {
  109.     ret_val = UIO_ERROR;
  110.     goto rtrn;
  111.   }
  112.  
  113.   for( wx=0; wx < nPEs; wx++, sp++ ) {
  114.       while( *sp != '\0' && *sp <= ' ' )
  115.     sp++;       /* skip white space */
  116.       if ( *sp == '\0' ) break;   /* no more data */
  117.       Datap[wx] = (*sp=='0'? 0.0:1.0);  /* set data */
  118.   }
  119.  
  120.   while( wx < nPEs ) Datap[wx++] = 0.0; /* no data for these */
  121.  
  122.       rtrn:
  123.   return(ret_val);
  124. }
  125.  
  126. /*ARGSUSED*/
  127. /* FUNCTION */
  128. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  129. NINT  LayN;
  130. NINT  nPEs;
  131. SREAL *Datap;
  132. {
  133.         char *sp;       /* string pointer */
  134.         int   wx;       /* work index */
  135.   NINT ret_val = UIO_OK;
  136.  
  137.   PutStr( "Enter desired Output as a single digit: " );
  138.   sp = GetStr();
  139.  
  140.   wx = 0;
  141.   while( *sp != '\0' && *sp <= ' ' )
  142.       sp++;       /* skip white space */
  143.   Datap[wx++] = (*sp=='0'? 0.0:1.0);  /* set data */
  144.  
  145.   while( wx < nPEs ) Datap[wx++] = 0.0; /* no data for these */
  146.  
  147.   return(ret_val);
  148. }
  149.  
  150.  
  151. /* */
  152. /*ARGSUSED*/
  153. /* FUNCTION */
  154. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  155. NINT  LayN;
  156. NINT  nPEs;
  157. SREAL *Datap;
  158. {
  159.   NINT ret_val = UIO_OK;
  160.  
  161.  
  162.   /* USER TO PLACE CODE HERE */
  163.  
  164.   return(ret_val);
  165. }
  166.  
  167.  
  168. /* FUNCTION */
  169. NINT UIO_Learn_End()
  170. {
  171.   NINT ret_val = UIO_OK;
  172.  
  173.  
  174.   /* USER TO PLACE CODE HERE */
  175.  
  176.   return(ret_val);
  177. }
  178.  
  179.  
  180. /* */
  181. /*******************************************************************/
  182. /*                                                                 */
  183. /*  Functions necessary for handling a recall or testing session.  */
  184. /*                                                                 */
  185. /*******************************************************************/
  186.  
  187. /* FUNCTION */
  188. NINT UIO_Recall_Start()
  189. {
  190.   NINT ret_val = UIO_OK;
  191.  
  192.  
  193.   /* USER TO PLACE CODE HERE */
  194.  
  195.   return(ret_val);
  196. }
  197.  
  198.  
  199. /* FUNCTION */
  200. NINT UIO_Read(LayN, nPEs, Datap)
  201. NINT  LayN;
  202. NINT  nPEs;
  203. SREAL *Datap;
  204. {
  205.   return( UIO_Learn_Input(LayN, nPEs, Datap ) );
  206. }
  207.  
  208.  
  209. /* */
  210. /*ARGSUSED*/
  211. /* FUNCTION */
  212. NINT UIO_Write(LayN, nPEs, Datap)
  213. NINT  LayN;
  214. NINT  nPEs;
  215. SREAL *Datap;
  216. {
  217.         char  buf[100];       /* work buffer */
  218.  
  219.   sprintf( buf, "Result is: %.3f\n", Datap[0] );
  220.   PutStr( buf );
  221.   return( UIO_UPDATE);      /* update display */
  222. }
  223.  
  224.  
  225. /*ARGSUSED*/
  226. /* FUNCTION */
  227. NINT UIO_Write_Step(LayN, nPEs, Datap)
  228. NINT  LayN;
  229. NINT  nPEs;
  230. SREAL *Datap;
  231. {
  232.   NINT ret_val = UIO_OK;
  233.  
  234.  
  235.   /* USER TO PLACE CODE HERE */
  236.  
  237.   return(ret_val);
  238. }
  239.  
  240.  
  241. /* */
  242. /* FUNCTION */
  243. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  244. NINT  LayN;
  245. NINT  nPEs;
  246. SREAL *Datap;
  247. {
  248.         return(UIO_Learn_Output(LayN, nPEs, Datap));
  249. }
  250.  
  251. /* FUNCTION */
  252. NINT UIO_Recall_End()
  253. {
  254.   NINT ret_val = UIO_OK;
  255.  
  256.  
  257.   /* USER TO PLACE CODE HERE */
  258.  
  259.   return(ret_val);
  260. }
  261.  
  262.  
  263. /* */
  264. /*******************************************************************/
  265. /*                                                                 */
  266. /*  Other miscellaneous functions.                                  */
  267. /*                                                                 */
  268. /*******************************************************************/
  269.  
  270. /*ARGSUSED*/
  271. /* FUNCTION */
  272. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  273. NINT  Instrument_id;
  274. NINT  nDataElems;
  275. SREAL *DataElemp;
  276. {
  277.   NINT ret_val = UIO_OK;
  278.  
  279.  
  280.   /* USER TO PLACE CODE HERE */
  281.  
  282.   return(ret_val);
  283. }
  284.  
  285.  
  286. /* FUNCTION */
  287. NINT UIO_Rewind()
  288. {
  289.   NINT ret_val = UIO_OK;
  290.  
  291.  
  292.   /* USER TO PLACE CODE HERE */
  293.  
  294.   return(ret_val);
  295. }
  296.  
  297.  
  298. /* */
  299. /*ARGSUSED*/
  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.  
  314.  
  315.  
  316.