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