home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 9 / 09.iso / e / e065 / 2.ddi / UIO_REQS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-28  |  30.0 KB  |  1,073 lines
  1. /*************************************************************/
  2. /*                                                           */
  3. /*    uio_reqs.c - User IO requests to NeuralWorks           */
  4. /*    Author: John C. Fairman           August 31, 1990      */
  5. /*    Copyright 1990 by NeuralWare Inc.                      */
  6. /*                                                           */
  7. /*    $Author   :  $                                         */
  8. /*    $Date     :  $                                         */
  9. /*    $Source   :  $                                         */
  10. /*    $Revision :  $                                         */
  11. /*    $Log      :  $                                         */
  12. /*                                                           */
  13. /*************************************************************/
  14.  
  15. #include "host.h"
  16.  
  17. #if defined(SUN)
  18. #include <sys/types.h>
  19. #endif
  20.  
  21. #ifdef MPW3
  22. #include <StdDef.h>
  23. #endif
  24.  
  25. #define UIO_SERVER             1
  26. #define HOME_FOR_UIO_DATA      1
  27. #define SKIP_COMPAT_DATA       1
  28. #include "userutl.h"
  29. #include "uio_strc.h"
  30. #include "uio_tran.h"
  31. #include "uio_reqs.pro"
  32.  
  33. #ifdef THINK_C
  34. #include "macuio.redef"
  35. #endif
  36.  
  37. #ifdef DLC
  38. /* --- prototypes --- */
  39.  
  40. InitGMenu( GMENU *, int, int );     /* Initialize a menu */
  41. DispGMenu( GMENU * );       /* Display graphics menu */
  42. DispGItem( GMENU *, GMENU_ITEM *, int, int ); /* Display menu item */
  43. GMENU_ITEM *LookGMenu( GMENU *, int * );  /* Look at graphics menu */
  44. #else
  45. GMENU_ITEM *LookGMenu();
  46. #endif
  47.  
  48. #if defined(MSDOS)
  49. #include <string.h>
  50. #endif
  51.  
  52. #define INALC 20
  53.  
  54. /* FUNCTION */
  55. LOCAL VOID send_request_with_id()
  56. {
  57.   Data_transfer_ptr->RPC_area.process_from_id = (BUFFER_INT)Process_id;
  58.   Data_transfer_ptr->RPC_area.process_to_id = (BUFFER_INT)HOST_PROCESS_ID;
  59.   Send_request();
  60.   if ((Data_transfer_ptr->RPC_area.request >= 0x80) &&      /* ERROR */
  61.     (Data_transfer_ptr->RPC_area.request < 0xC0))
  62.   {
  63.     UIO_error_value = Data_transfer_ptr->RPC_area.request;
  64.   }
  65. }
  66.  
  67. /* FUNCTION */
  68. EXPORT TEXT *GetStr()
  69. {
  70.   RPC_AREA_T  *rpc;
  71.   static TEXT ag_msg[MAX_UIO_STRING];
  72.  
  73.   rpc = &Data_transfer_ptr->RPC_area;
  74.   rpc->request = REQ_GETSTR;
  75.  
  76.   send_request_with_id();
  77.  
  78.   strcpy(ag_msg, rpc->all_arg_lists.argmsg.ag_msg);
  79.  
  80.   return(ag_msg);
  81. }
  82.  
  83. /* FUNCTION */
  84. EXPORT VOID PutStr( sp )
  85. TEXT *sp;
  86. {
  87.   RPC_AREA_T *rpc;
  88.  
  89.   rpc = &Data_transfer_ptr->RPC_area;
  90.   rpc->request = REQ_PUTSTR;
  91.   strcpy(rpc->all_arg_lists.argmsg.ag_msg, sp);
  92.  
  93.   send_request_with_id();
  94. }
  95.  
  96. /* */
  97. /* FUNCTION */
  98. EXPORT VOID PutFmt(fmt, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
  99.                         b0, b1, b2, b3, b4, b5, b6, b7, b8, b9)
  100. TEXT *fmt;
  101. UL   a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
  102.      b0, b1, b2, b3, b4, b5, b6, b7, b8, b9;
  103. {
  104.   RPC_AREA_T *rpc;
  105.   ARGFMT     *argfmt;
  106.  
  107.   rpc = &Data_transfer_ptr->RPC_area;
  108.   rpc->request = REQ_PUTFMT;
  109.   argfmt = &rpc->all_arg_lists.argfmt;
  110.  
  111. #if (PIGS_EVER_FLY)
  112.   strcpy(argfmt->format, fmt);
  113.   argfmt->format_args[ 0] = a0;
  114.   argfmt->format_args[ 1] = a1;
  115.   argfmt->format_args[ 2] = a2;
  116.   argfmt->format_args[ 3] = a3;
  117.   argfmt->format_args[ 4] = a4;
  118.   argfmt->format_args[ 5] = a5;
  119.   argfmt->format_args[ 6] = a6;
  120.   argfmt->format_args[ 7] = a7;
  121.   argfmt->format_args[ 8] = a8;
  122.   argfmt->format_args[ 9] = a9;
  123.   argfmt->format_args[10] = b0;
  124.   argfmt->format_args[11] = b1;
  125.   argfmt->format_args[12] = b2;
  126.   argfmt->format_args[13] = b3;
  127.   argfmt->format_args[14] = b4;
  128.   argfmt->format_args[15] = b5;
  129.   argfmt->format_args[16] = b6;
  130.   argfmt->format_args[17] = b7;
  131.   argfmt->format_args[18] = b8;
  132.   argfmt->format_args[19] = b9;
  133. #else
  134.   /* CCK: 12-Apr-91 This is the one that works!! */
  135.   sprintf(argfmt->format, fmt,
  136.       a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
  137.       b0, b1, b2, b3, b4, b5, b6, b7, b8, b9);
  138. #endif
  139.  
  140.   send_request_with_id();
  141. }
  142.  
  143. /* FUNCTION */
  144. EXPORT VOID SaveNet( NetName, Mode )
  145. TEXT *NetName;
  146. NINT Mode;       /* 0=binary, 1=ascii, 2=annotated, 3=screen dump */
  147. {
  148.   RPC_AREA_T *rpc;
  149.  
  150.   rpc = &Data_transfer_ptr->RPC_area;
  151.   rpc->request = REQ_SAVENET;
  152.   strcpy(rpc->all_arg_lists.argn.ag_NetN, NetName);
  153.   rpc->all_arg_lists.argn.ag_mode = (BUFFER_UINT)Mode;
  154.  
  155.   send_request_with_id();
  156. }
  157.  
  158.  
  159. /* */
  160. /*****************************************************************************/
  161. /*                                                                           */
  162. /*    Graphic Routine interfaces for NWORKS                                  */
  163. /*                                                                           */
  164. /*****************************************************************************/
  165.  
  166. /* FUNCTION */
  167. EXPORT VOID ug_window( key, bkcolor, x0, y0, x1, y1 )
  168. NINT key;        /* window number for a handle (1..8) */
  169. NINT bkcolor;    /* background color */
  170. NINT x0, y0;     /* screen coordinates of origin (bottom left corner) */
  171. NINT x1, y1;     /* screen coordinates of top right corner */
  172. {
  173.   RPC_AREA_T *rpc;
  174.   ARG1       *arg1;
  175.  
  176.   rpc = &Data_transfer_ptr->RPC_area;
  177.   rpc->request = REQ_UG_WINDOW;
  178.   arg1 = &rpc->all_arg_lists.arg1;
  179.   arg1->ag_winn = (BUFFER_UINT)key;
  180.   arg1->ag_color = (BUFFER_UINT)bkcolor;
  181.   arg1->ag_x0 = (BUFFER_UINT)x0;
  182.   arg1->ag_y0 = (BUFFER_UINT)y0;
  183.   arg1->ag_x1 = (BUFFER_UINT)x1;
  184.   arg1->ag_y1 = (BUFFER_UINT)y1;
  185.  
  186.   send_request_with_id();
  187. }
  188.  
  189. /* FUNCTION */
  190. EXPORT VOID ug_line( key, color, mode, x0, y0, x1, y1, style )
  191. NINT key;        /* window number for a handle (1..8) */
  192. NINT color;      /* color index */
  193. NINT mode;       /* 0=set, 1=xor */
  194. NINT x0, y0;     /* window relative coordinates for origin */
  195. NINT x1, y1;     /* window relative coordinates for end */
  196. NINT style;      /* line style */
  197. {
  198.   RPC_AREA_T *rpc;
  199.   ARG2       *arg2;
  200.  
  201.   rpc = &Data_transfer_ptr->RPC_area;
  202.   rpc->request = REQ_UG_LINE;
  203.   arg2 = &rpc->all_arg_lists.arg2;
  204.   arg2->ag_winn = (BUFFER_UINT)key;
  205.   arg2->ag_color = (BUFFER_UINT)color;
  206.   arg2->ag_mode = (BUFFER_UINT)mode;
  207.   arg2->ag_x0 = (BUFFER_UINT)x0;
  208.   arg2->ag_y0 = (BUFFER_UINT)y0;
  209.   arg2->ag_x1 = (BUFFER_UINT)x1;
  210.   arg2->ag_y1 = (BUFFER_UINT)y1;
  211.   arg2->ag_style = (BUFFER_UINT)style;
  212.  
  213.   send_request_with_id();
  214. }
  215.  
  216. /* */
  217. /* FUNCTION */
  218. EXPORT VOID ug_point( key, color, mode, x0, y0 )
  219. NINT key;        /* window number for a handle (1..8) */
  220. NINT color;      /* color index */
  221. NINT mode;       /* 0=set, 1=xor */
  222. NINT x0, y0;     /* window relative coordinates for point */
  223. {
  224.   RPC_AREA_T *rpc;
  225.   ARG2       *arg2;
  226.  
  227.   rpc = &Data_transfer_ptr->RPC_area;
  228.   rpc->request = REQ_UG_POINT;
  229.   arg2 = &rpc->all_arg_lists.arg2;
  230.   arg2->ag_winn = (BUFFER_UINT)key;
  231.   arg2->ag_color = (BUFFER_UINT)color;
  232.   arg2->ag_mode = (BUFFER_UINT)mode;
  233.   arg2->ag_x0 = (BUFFER_UINT)x0;
  234.   arg2->ag_y0 = (BUFFER_UINT)y0;
  235.  
  236.   send_request_with_id();
  237. }
  238.  
  239. /* FUNCTION */
  240. EXPORT VOID ug_box( key, color, mode, x0, y0, x1, y1, style )
  241. NINT key;        /* window number for a handle (1..8) */
  242. NINT color;      /* color index */
  243. NINT mode;       /* 0=set, 1=xor */
  244. NINT x0, y0;     /* window relative coordinates for lower left corner */
  245. NINT x1, y1;     /* window relative coordinates for upper right corner */
  246. NINT style;      /* line style */
  247. {
  248.   RPC_AREA_T *rpc;
  249.   ARG2       *arg2;
  250.  
  251.   rpc = &Data_transfer_ptr->RPC_area;
  252.   rpc->request = REQ_UG_BOX;
  253.   arg2 = &rpc->all_arg_lists.arg2;
  254.   arg2->ag_winn = (BUFFER_UINT)key;
  255.   arg2->ag_color = (BUFFER_UINT)color;
  256.   arg2->ag_mode = (BUFFER_UINT)mode;
  257.   arg2->ag_x0 = (BUFFER_UINT)x0;
  258.   arg2->ag_y0 = (BUFFER_UINT)y0;
  259.   arg2->ag_x1 = (BUFFER_UINT)x1;
  260.   arg2->ag_y1 = (BUFFER_UINT)y1;
  261.   arg2->ag_style = (BUFFER_UINT)style;
  262.  
  263.   send_request_with_id();
  264. }
  265.  
  266. /* */
  267. /* FUNCTION */
  268. EXPORT VOID ug_boxf( key, color, mode, x0, y0, x1, y1 )
  269. NINT key;        /* window number for a handle (1..8) */
  270. NINT color;      /* color index */
  271. NINT mode;       /* 0=set, 1=xor */
  272. NINT x0, y0;     /* window relative coordinates for lower left corner */
  273. NINT x1, y1;     /* window relative coordinates for upper right corner */
  274. {
  275.   RPC_AREA_T *rpc;
  276.   ARG2 *arg2;
  277.  
  278.   rpc = &Data_transfer_ptr->RPC_area;
  279.   rpc->request = REQ_UG_BOXF;
  280.   arg2 = &rpc->all_arg_lists.arg2;
  281.   arg2->ag_winn = (BUFFER_UINT)key;
  282.   arg2->ag_color = (BUFFER_UINT)color;
  283.   arg2->ag_mode = (BUFFER_UINT)mode;
  284.   arg2->ag_x0 = (BUFFER_UINT)x0;
  285.   arg2->ag_y0 = (BUFFER_UINT)y0;
  286.   arg2->ag_x1 = (BUFFER_UINT)x1;
  287.   arg2->ag_y1 = (BUFFER_UINT)y1;
  288.  
  289.   send_request_with_id();
  290. }
  291.  
  292. /* FUNCTION */
  293. EXPORT VOID ug_puts( key, color, mode, x0, y0, sp, rot )
  294. NINT key;        /* window number for a handle (1..8) */
  295. NINT color;      /* color index */
  296. NINT mode;       /* 0=set, 1=xor */
  297. NINT x0, y0;     /* window relative coordinates for lower left corner */
  298. TEXT *sp;        /* string to draw */
  299. NINT rot;        /* rotation angle */
  300. {
  301.   RPC_AREA_T *rpc;
  302.   ARGS *args;
  303.  
  304.   rpc = &Data_transfer_ptr->RPC_area;
  305.   rpc->request = REQ_UG_PUTS;
  306.   args = &rpc->all_arg_lists.args;
  307.   args->ag_winn = (BUFFER_UINT)key;
  308.   args->ag_color = (BUFFER_UINT)color;
  309.   args->ag_mode = (BUFFER_UINT)mode;
  310.   args->ag_x0 = (BUFFER_UINT)x0;
  311.   args->ag_y0 =(BUFFER_UINT) y0;
  312.   strcpy((TEXT *)args->ag_sp, sp);
  313.   args->ag_rot = (BUFFER_UINT)rot;
  314.  
  315.   send_request_with_id();
  316. }
  317.  
  318. /* */
  319. /* FUNCTION */
  320. EXPORT VOID ug_windel( key )
  321. NINT key;        /* window number to delete; 0=delete all windows */
  322. {
  323.   RPC_AREA_T *rpc;
  324.   ARG3       *arg3;
  325.  
  326.   rpc = &Data_transfer_ptr->RPC_area;
  327.   rpc->request = REQ_UG_WINDEL;
  328.   arg3 = &rpc->all_arg_lists.arg3;
  329.   arg3->ag_winn = (BUFFER_UINT)key;
  330.   
  331.   send_request_with_id();
  332. }
  333.  
  334. /* FUNCTION */
  335. EXPORT VOID ug_winclr( key )
  336. NINT key;        /* clear the contents of this window */
  337. {
  338.   RPC_AREA_T *rpc;
  339.   ARG3       *arg3;
  340.  
  341.   rpc = &Data_transfer_ptr->RPC_area;
  342.   rpc->request = REQ_UG_WINCLR;
  343.   arg3 = &rpc->all_arg_lists.arg3;
  344.   arg3->ag_winn = (BUFFER_UINT)key;
  345.  
  346.   send_request_with_id();
  347. }
  348.  
  349. /* FUNCTION */
  350. EXPORT VOID ug_gparms( xsizep, ysizep, ncolorp, chrxp, chryp )
  351. NINT *xsizep;    /* width  of user area in x-pixels */
  352. NINT *ysizep;    /* height of user area in y-pixels */
  353. NINT *ncolorp;   /* # of colors (including background) */
  354. NINT *chrxp;     /* # of x-pixels in a Character */
  355. NINT *chryp;     /* # of y-pixels in a Character */
  356. {
  357.   RPC_AREA_T *rpc;
  358.   AGPARMS    *agparms;
  359.  
  360.   rpc = &Data_transfer_ptr->RPC_area;
  361.   rpc->request = REQ_UG_GPARMS;
  362.   agparms = &rpc->all_arg_lists.agparms;
  363.  
  364.   send_request_with_id();
  365.  
  366.   if (UIO_error_value == 0)
  367.   {
  368.     *xsizep = (NINT)agparms->xsize;
  369.     *ysizep = (NINT)agparms->ysize;
  370.     *ncolorp = (NINT)agparms->ncolor;
  371.     *chrxp = (NINT)agparms->chrx;
  372.     *chryp = (NINT)agparms->chry;
  373.   }
  374. }
  375.  
  376. /* */
  377. /* FUNCTION */
  378. EXPORT VOID ug_mouse( keyp, xp, yp, mp )
  379. NINT *keyp;      /* poNINTer to window number mouse is in */
  380. NINT *xp;        /* pointer to relative x-coordinate */
  381. NINT *yp;        /* pointer to relative y-coordinate */
  382. NINT *mp;        /* button press codes */
  383. {
  384.   RPC_AREA_T *rpc;
  385.   AMOUSE     *amouse;
  386.  
  387.   rpc = &Data_transfer_ptr->RPC_area;
  388.   rpc->request = REQ_UG_MOUSE;
  389.   amouse = &rpc->all_arg_lists.amouse;
  390.  
  391.   send_request_with_id();
  392.  
  393.   if (UIO_error_value == 0)
  394.   {
  395.     *keyp = (NINT)amouse->key;
  396.     *xp = (NINT)amouse->xloc;
  397.     *yp = (NINT)amouse->yloc;
  398.     *mp = (NINT)amouse->buttonstates;
  399.   }
  400. }
  401.  
  402. /* FUNCTION */
  403. EXPORT NINT ug_rdpoint( key, x0, y0 )
  404. NINT key;        /* window number for a handle (1..8) */
  405. NINT x0, y0;     /* window relative coordinates for lower left corner */
  406. {
  407.   RPC_AREA_T *rpc;
  408.   ARG3       *arg3;
  409.  
  410.   rpc = &Data_transfer_ptr->RPC_area;
  411.   rpc->request = REQ_UG_RDPOINT;
  412.   arg3 = &rpc->all_arg_lists.arg3;
  413.   arg3->ag_winn = (BUFFER_UINT)key;
  414.   arg3->ag_x0 = (BUFFER_UINT)x0;
  415.   arg3->ag_y0 = (BUFFER_UINT)y0;
  416.  
  417.   send_request_with_id();
  418.  
  419.   return((NINT)rpc->return_value.buffer_int);
  420. }
  421.  
  422. /* */
  423. /* FUNCTION */
  424. EXPORT VOID ug_rdnetinf( nlayp, ninp, noutp, ltypep, cspp, netnpp )
  425. NINT *nlayp;     /* return pointer to number of layers will be */
  426. NINT *ninp;      /* return pointer to number of inputs */
  427. NINT *noutp;     /* return pointer to number of outputs */
  428. NINT *ltypep;    /* return pointer to layer type (0=hetero; 1=auto) */
  429. TEXT **cspp;     /* return pointer to control strategy name */
  430. TEXT **netnpp;   /* return pointer to network file name */
  431. {
  432.   RPC_AREA_T  *rpc;
  433.   ARDNETINF   *ardnetinf;
  434.   static TEXT cs[FNALC]  = {0};
  435.   static TEXT netn[FNALC]= {0};
  436.  
  437.   rpc = &Data_transfer_ptr->RPC_area;
  438.   rpc->request = REQ_UG_RDNETINF;
  439.   ardnetinf = &rpc->all_arg_lists.ardnetinf;
  440.  
  441.   send_request_with_id();
  442.  
  443.   if (UIO_error_value == 0)
  444.   {
  445.     *nlayp = (NINT)ardnetinf->nlay;
  446.     *ninp = (NINT)ardnetinf->nin;
  447.     *noutp = (NINT)ardnetinf->nout;
  448.     *ltypep = (NINT)ardnetinf->ltype;
  449.     if (ardnetinf->cs[0] == '\0')
  450.     {
  451.       *cspp = *netnpp = NULL;
  452.     }
  453.     else
  454.     {
  455.       strcpy(cs, (TEXT *)ardnetinf->cs);
  456.       strcpy(netn, (TEXT *)ardnetinf->netn);
  457.       *cspp = cs;
  458.       *netnpp = netn;
  459.     }
  460.   }
  461. }
  462.  
  463. /* FUNCTION */
  464. EXPORT TEXT *ug_getinstrt()
  465. {
  466.   RPC_AREA_T  *rpc;
  467.   static TEXT ag_msg[INALC];
  468.  
  469.   rpc = &Data_transfer_ptr->RPC_area;
  470.   rpc->request = REQ_UG_GETINSTRT;
  471.  
  472.   send_request_with_id();
  473.  
  474.   strcpy(ag_msg, (TEXT *)rpc->all_arg_lists.argmsg.ag_msg);
  475.  
  476.   return(ag_msg);
  477. }
  478.  
  479. /* FUNCTION */
  480. EXPORT NINT ug_loadnet( NetName )
  481. TEXT *NetName;   /* root name of network to load */
  482. {
  483.   RPC_AREA_T *rpc;
  484.  
  485.   rpc = &Data_transfer_ptr->RPC_area;
  486.   rpc->request = REQ_UG_LOADNET;
  487.   strcpy(rpc->all_arg_lists.argn.ag_NetN, NetName);
  488.  
  489.   send_request_with_id();
  490.  
  491.   return((NINT)rpc->return_value.buffer_int);
  492. }
  493.  
  494. /* */
  495. /* FUNCTION */
  496. EXPORT NINT ug_learn( trials )
  497. TRIAL_NUM_T trials;
  498. {
  499.   RPC_AREA_T *rpc;
  500.   ARGLR      *arglr;
  501.  
  502.   rpc = &Data_transfer_ptr->RPC_area;
  503.   rpc->request = REQ_UG_LEARN;
  504.   arglr = &rpc->all_arg_lists.arglr;
  505.   arglr->ag_count = (BUFFER_LONG)trials;
  506.  
  507.   send_request_with_id();
  508.  
  509.   return((NINT)rpc->return_value.buffer_int);
  510. }
  511.  
  512. /* FUNCTION */
  513. EXPORT NINT ug_recall( trials )
  514. TRIAL_NUM_T trials;
  515. {
  516.   RPC_AREA_T *rpc;
  517.   ARGLR      *arglr;
  518.  
  519.   rpc = &Data_transfer_ptr->RPC_area;
  520.   rpc->request = REQ_UG_RECALL;
  521.   arglr = &rpc->all_arg_lists.arglr;
  522.   arglr->ag_count = (BUFFER_LONG)trials;
  523.  
  524.   send_request_with_id();
  525.  
  526.   return((NINT)rpc->return_value.buffer_int);
  527. }
  528.  
  529. /* FUNCTION */
  530. EXPORT NINT ug_test( trials )
  531. TRIAL_NUM_T trials;
  532. {
  533.   RPC_AREA_T *rpc;
  534.   ARGLR      *arglr;
  535.  
  536.   rpc = &Data_transfer_ptr->RPC_area;
  537.   rpc->request = REQ_UG_TEST;
  538.   arglr = &rpc->all_arg_lists.arglr;
  539.   arglr->ag_count = (BUFFER_LONG)trials;
  540.  
  541.   send_request_with_id();
  542.  
  543.   return((NINT)rpc->return_value.buffer_int);
  544. }
  545.  
  546. /* FUNCTION */
  547. EXPORT NINT ug_msgio( msg, msgl, rwf )
  548. TEXT *msg;       /* message to send / read */
  549. NINT msgl;       /* message length */
  550. NINT rwf;        /* 0=read; 1=write */
  551. {
  552.   RPC_AREA_T *rpc;
  553.   ARGMSG     *argmsg;
  554.  
  555.   rpc = &Data_transfer_ptr->RPC_area;
  556.   rpc->request = REQ_UG_MSGIO;
  557.   argmsg = &rpc->all_arg_lists.argmsg;
  558.   argmsg->ag_msgl = msgl;
  559.   argmsg->ag_msgdir = (BUFFER_UINT)rwf;
  560.   if (rwf)
  561.     strcpy(argmsg->ag_msg, msg);
  562.  
  563.   send_request_with_id();
  564.  
  565.   if (UIO_error_value == 0)
  566.   {
  567.     if (!rwf)
  568.       strcpy(msg, argmsg->ag_msg);
  569.   }
  570.   return((NINT)rpc->return_value.buffer_int);
  571. }
  572.  
  573. /* */
  574. /* FUNCTION */
  575. EXPORT VOID ug_wtstats( PStat )
  576. PRSTATS *PStat;  /* statistics */
  577. {
  578.   RPC_AREA_T  *rpc;
  579.   PRSTATS_BUF *prstats_buf;
  580.   NINT        lcv;
  581.  
  582.   rpc = &Data_transfer_ptr->RPC_area;
  583.   rpc->request = REQ_UG_WTSTATS;
  584.   prstats_buf = &rpc->all_arg_lists.prstats_buf;
  585.  
  586. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  587.   MOVEMEM(prstats_buf, PStat, sizeof(PRSTATS_BUF));
  588. #else
  589.   prstats_buf->PRNwts = PStat->PRNwts;
  590.   prstats_buf->PRMin = PStat->PRMin;
  591.   prstats_buf->PRMax = PStat->PRMax;
  592.   prstats_buf->PRSum = PStat->PRSum;
  593.   prstats_buf->PRAverage = PStat->PRAverage;
  594.   prstats_buf->PRMedian = PStat->PRMedian;
  595.   for (lcv=0; lcv<NPHIST; lcv++)
  596.     prstats_buf->PRHist[lcv] = PStat->PRHist[lcv];;
  597.   prstats_buf->PRMinA = PStat->PRMinA;
  598.   prstats_buf->PRMaxA = PStat->PRMaxA;
  599.   prstats_buf->PRSumA = PStat->PRSumA;
  600.   prstats_buf->PRAverageA = PStat->PRAverageA;
  601.   prstats_buf->PRMedianA = PStat->PRMedianA;
  602.   for (lcv=0; lcv<NPHIST; lcv++)
  603.     prstats_buf->PRHistA[lcv] = PStat->PRHistA[lcv];;
  604. #endif
  605.  
  606.   send_request_with_id();
  607. }
  608.  
  609. /* FUNCTION */
  610. EXPORT VOID ug_prune( mode, PrThresh, Prob, WtMax )
  611. NINT mode;     /* prune mode */
  612. REAL PrThresh; /* pruning threshold */
  613. REAL Prob;     /* stochastic probability */
  614. REAL WtMax;    /* maximum magnitude to limit wts to */
  615. {
  616.   RPC_AREA_T *rpc;
  617.   ARGPRUNE *argprune;
  618.  
  619.   rpc = &Data_transfer_ptr->RPC_area;
  620.   rpc->request = REQ_UG_PRUNE;
  621.   argprune = &rpc->all_arg_lists.argprune;
  622.   argprune->pr_mode = (BUFFER_UINT)mode;
  623.   argprune->pr_thresh = (BUFFER_REAL)PrThresh;
  624.   argprune->pr_prob = (BUFFER_REAL)Prob;
  625.   argprune->pr_wtmax = (BUFFER_REAL)WtMax;
  626.  
  627.   send_request_with_id();
  628. }
  629.  
  630. /* */
  631. /* FUNCTION */
  632. EXPORT VOID ug_blit(key, mode, x0, y0, x_exp, y_exp, x_size, y_size, data)
  633. NINT key;           /* window number for a handle (1..8) */
  634. NINT mode;          /* 0=set, 1=xor */
  635. NINT x0, y0;        /* window relative coordinates for lower left corner */
  636. NINT x_exp, y_exp;  /* How many pixels to expand each bit in the x and */
  637.                     /*   y direction                                   */
  638. NINT x_size,y_size; /* the size of the mask in the x and y direction   */
  639. TEXT *data;         /* the data to be blitted. one byte per char and   */
  640.                     /* the value of that byte determines the color put */
  641.                     /* on the screen. The bytes start at bottom right  */
  642.                     /* and then fill the first row, then next row up   */
  643.                     /* to top.                                         */
  644. {
  645.   RPC_AREA_T *rpc;
  646.   ARGBLIT    *argblit;
  647.  
  648.   rpc = &Data_transfer_ptr->RPC_area;
  649.   rpc->request = REQ_UG_BLIT;
  650.   argblit = &rpc->all_arg_lists.argblit;
  651.   argblit->ag_winn = (BUFFER_UINT)key;
  652.   argblit->ag_mode = (BUFFER_UINT)mode;
  653.   argblit->ag_x0 = (BUFFER_UINT)x0;
  654.   argblit->ag_y0 = (BUFFER_UINT)y0;
  655.   argblit->ag_x_exp = (BUFFER_UINT)x_exp;
  656.   argblit->ag_y_exp = (BUFFER_UINT)y_exp;
  657.   argblit->ag_x_size = (BUFFER_UINT)x_size;
  658.   argblit->ag_y_size = (BUFFER_UINT)y_size;
  659.   MOVEMEM(argblit->ag_blit_bytes, data, x_size*y_size);
  660.  
  661.   send_request_with_id();
  662. }
  663.  
  664. /* FUNCTION */
  665. EXPORT VOID ug_pblit( key, color, mode, x0, y0, wid, ht, rot, ptr )
  666. NINT key;        /* window handle */
  667. NINT color;      /* color of pattern */
  668. NINT mode;       /* 0=set, 1=xor */
  669. NINT x0, y0;     /* window relative coordinates for lower left corner */
  670. NINT wid, ht;    /* width & height of blit area in pixels */
  671. NINT rot;        /* rotation angle */
  672. TEXT *ptr;       /* pointer to the blit data */
  673. {
  674.   RPC_AREA_T *rpc;
  675.   ARGPBLIT   *argpblit;
  676.  
  677.   rpc = &Data_transfer_ptr->RPC_area;
  678.   rpc->request = REQ_UG_PBLIT;
  679.   argpblit = &rpc->all_arg_lists.argpblit;
  680.   argpblit->ag_winn = (BUFFER_UINT)key;
  681.   argpblit->ag_color = (BUFFER_UINT)color;
  682.   argpblit->ag_mode = (BUFFER_UINT)mode;
  683.   argpblit->ag_x0 = (BUFFER_UINT)x0;
  684.   argpblit->ag_y0 = (BUFFER_UINT)y0;
  685.   argpblit->ag_x_size = (BUFFER_UINT)wid;
  686.   argpblit->ag_y_size = (BUFFER_UINT)ht;
  687.   argpblit->ag_rot = rot;
  688.   MOVEMEM(argpblit->ag_blit_bytes, ptr, wid*ht);
  689.  
  690.   send_request_with_id();
  691. }
  692.  
  693. /* */
  694. /* FUNCTION */
  695. EXPORT NINT ug_peio( apep, rwf, LayN, PEN )
  696. APE  *apep;      /* poiner to PE data */
  697. NINT rwf;        /* 0=read; 1=write */
  698. NINT LayN;       /* layer number 0=input,... */
  699. NINT PEN;        /* PE within layer 0=first, ... */
  700. {
  701.   RPC_AREA_T *rpc;
  702.   ARGPSCIO   *argpscio;
  703.  
  704.   rpc = &Data_transfer_ptr->RPC_area;
  705.   rpc->request = REQ_UG_PEIO;
  706.   argpscio = &rpc->all_arg_lists.argpscio;
  707.   argpscio->ag_rwf = (BUFFER_UINT)rwf;
  708.   argpscio->ag_layern = LayN;
  709.   argpscio->ag_pen = PEN;
  710.   if (rwf)
  711.   {
  712. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  713.     MOVEMEM(&argpscio->ag_rdata.ag_pe, apep, sizeof(APE));
  714. #else
  715.     argpscio->ag_rdata.ag_pe.ape_I = apep->ape_I;
  716.     argpscio->ag_rdata.ag_pe.ape_Tran = apep->ape_Tran;
  717.     argpscio->ag_rdata.ag_pe.ape_Output = apep->ape_Output;
  718.     argpscio->ag_rdata.ag_pe.ape_Err = apep->ape_Err;
  719.     argpscio->ag_rdata.ag_pe.ape_CumErr = apep->ape_CumErr;
  720.     argpscio->ag_rdata.ag_pe.ape_Flags = apep->ape_Flags;
  721. #endif
  722.   }
  723.  
  724.   send_request_with_id();
  725.  
  726.   if (!rwf)
  727.   {
  728. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  729.     MOVEMEM(apep, &argpscio->ag_rdata.ag_pe, sizeof(APE));
  730. #else
  731.     apep->ape_I = argpscio->ag_rdata.ag_pe.ape_I;
  732.     apep->ape_Tran = argpscio->ag_rdata.ag_pe.ape_Tran;
  733.     apep->ape_Output = argpscio->ag_rdata.ag_pe.ape_Output;
  734.     apep->ape_Err = argpscio->ag_rdata.ag_pe.ape_Err;
  735.     apep->ape_CumErr = argpscio->ag_rdata.ag_pe.ape_CumErr;
  736.     apep->ape_Flags = argpscio->ag_rdata.ag_pe.ape_Flags;
  737. #endif
  738.   }
  739.  
  740.   return((NINT)rpc->return_value.buffer_int);
  741. }
  742.  
  743. /* */
  744. /* FUNCTION */
  745. EXPORT NINT ug_schdio( schp, rwf, LayN )
  746. ASCHED *schp;    /* pointer to schedule date */
  747. NINT   rwf;      /* 0=read; 1=write */
  748. NINT   LayN;     /* layer number 0=input, ... */
  749. {
  750.   RPC_AREA_T *rpc;
  751.   ARGPSCIO   *argpscio;
  752.  
  753.   rpc = &Data_transfer_ptr->RPC_area;
  754.   rpc->request = REQ_UG_SCHDIO;
  755.   argpscio = &rpc->all_arg_lists.argpscio;
  756.   argpscio->ag_rwf = (BUFFER_UINT)rwf;
  757.   argpscio->ag_layern = LayN;
  758.   if (rwf)
  759.   {
  760. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  761.     MOVEMEM(&argpscio->ag_rdata.ag_sched, schp, sizeof(ASCHED));
  762. #else
  763.     int lcv1, lcv2;
  764.  
  765.     strcpy(argpscio->ag_rdata.ag_sched.asc_nam, schp->asc_nam);
  766.     for (lcv1=0; lcv1<5; lcv1++)
  767.     {
  768.       argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_recall =
  769.         schp->asc_col[lcv1].asc_recall;
  770.       for (lcv2=0; lcv2<5; lcv2++)
  771.       {
  772.         argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_rcl[lcv2] =
  773.           schp->asc_col[lcv1].asc_rcl[lcv2];
  774.       }
  775.       argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_learn =
  776.         schp->asc_col[lcv1].asc_learn;
  777.       for (lcv2=0; lcv2<5; lcv2++)
  778.       {
  779.         argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_lrn[lcv2] =
  780.           schp->asc_col[lcv1].asc_lrn[lcv2];
  781.       }
  782.     }
  783. #endif
  784.   }
  785.  
  786.   send_request_with_id();
  787.  
  788. /* */
  789.   if (UIO_error_value == 0)
  790.   {
  791.     if (!rwf)
  792.     {
  793. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  794.       MOVEMEM(schp, &argpscio->ag_rdata.ag_sched, sizeof(ASCHED));
  795. #else
  796.       int lcv1, lcv2;
  797.  
  798.       strcpy(schp->asc_nam, argpscio->ag_rdata.ag_sched.asc_nam);
  799.       for (lcv1=0; lcv1<5; lcv1++)
  800.       {
  801.         schp->asc_col[lcv1].asc_recall =
  802.           argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_recall;
  803.         for (lcv2=0; lcv2<5; lcv2++)
  804.         {
  805.           schp->asc_col[lcv1].asc_rcl[lcv2] =
  806.             argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_rcl[lcv2];
  807.         }
  808.         schp->asc_col[lcv1].asc_learn =
  809.           argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_learn;
  810.         for (lcv2=0; lcv2<5; lcv2++)
  811.         {
  812.           schp->asc_col[lcv1].asc_lrn[lcv2] =
  813.             argpscio->ag_rdata.ag_sched.asc_col[lcv1].asc_lrn[lcv2];
  814.         }
  815.       }
  816. #endif
  817.     }
  818.   }
  819.  
  820.   return((NINT)rpc->return_value.buffer_int);
  821. }
  822.  
  823. /* */
  824. /* FUNCTION */
  825. EXPORT NINT ug_ctrio( ctrp, rwf)
  826. CTRIO_T *ctrp;        /* pointer to array of 8-LONGs */
  827. NINT    rwf;          /* 0=read; 1=write */
  828. {
  829.   RPC_AREA_T *rpc;
  830.   ARGPSCIO   *argpscio;
  831.   NINT       lcv;
  832.  
  833.   rpc = &Data_transfer_ptr->RPC_area;
  834.   rpc->request = REQ_UG_CTRIO;
  835.   argpscio = &rpc->all_arg_lists.argpscio;
  836.   argpscio->ag_rwf = (BUFFER_UINT)rwf;
  837.   if (rwf)
  838. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  839.     MOVEMEM(argpscio->ag_rdata.ag_ctr, ctrp, sizeof(CTRIO_T) * 8);
  840. #else
  841.     for (lcv=0; lcv<8; lcv++)
  842.       argpscio->ag_rdata.ag_ctr[lcv] = (BUFFER_LONG)ctrp[lcv];
  843. #endif
  844.  
  845.   send_request_with_id();
  846.  
  847.   if (UIO_error_value == 0)
  848.   {
  849.     if (!rwf)
  850. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  851.       MOVEMEM(ctrp, argpscio->ag_rdata.ag_ctr, sizeof(CTRIO_T) * 8);
  852. #else
  853.       for (lcv=0; lcv<8; lcv++)
  854.         ctrp[lcv] = (SL)argpscio->ag_rdata.ag_ctr[lcv];
  855. #endif
  856.   }
  857.   return((NINT)rpc->return_value.buffer_int);
  858. }
  859.  
  860. /* */
  861. /* FUNCTION */
  862. EXPORT NINT ug_ioparms(ioparms, rwf)
  863. IOPARMS *ioparms;
  864. NINT       rwf;  /* 0=read; 1=write */
  865. {
  866.   RPC_AREA_T  *rpc;
  867.   IOPARMS_BUF *ioparms_buf;
  868.  
  869.   rpc = &Data_transfer_ptr->RPC_area;
  870.   rpc->request = REQ_UG_IOPARMS;
  871.   rpc->all_arg_lists.argpscio.ag_rwf = (BUFFER_UINT)rwf;
  872.   ioparms_buf = &rpc->all_arg_lists.argpscio.ag_rdata.ioparms_buf;
  873.   if (rwf)
  874.   {
  875. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  876.     MOVEMEM(ioparms_buf, ioparms, sizeof(IOPARMS));
  877. #else
  878.     ioparms_buf->start_in = ioparms->start_in;
  879.     ioparms_buf->min_in = ioparms->min_in;
  880.     ioparms_buf->max_in = ioparms->max_in;
  881.     ioparms_buf->start_out = ioparms->start_out;
  882.     ioparms_buf->min_out = ioparms->min_out;
  883.     ioparms_buf->max_out = ioparms->max_out;
  884. #endif
  885.   }
  886.  
  887.   send_request_with_id();
  888.  
  889.   if (UIO_error_value == 0)
  890.   {
  891.     if (!rwf)
  892.     {
  893. #if (SERVPRIMS_EQ_BUFFERPRIMS)
  894.       MOVEMEM(ioparms, ioparms_buf, sizeof(IOPARMS));
  895. #else
  896.       ioparms->start_in = ioparms_buf->start_in;
  897.       ioparms->min_in = ioparms_buf->min_in;
  898.       ioparms->max_in = ioparms_buf->max_in;
  899.       ioparms->start_out = ioparms_buf->start_out;
  900.       ioparms->min_out = ioparms_buf->min_out;
  901.       ioparms->max_out = ioparms_buf->max_out;
  902. #endif
  903.     }
  904.   }
  905. }
  906.  
  907. /* */
  908. /* FUNCTION */
  909. EXPORT REAL ug_cnio(LayN, PEN, var_idx, rwf, value)
  910. NINT   LayN;     /* layer number 0=input,... */
  911. NINT   PEN;      /* PE within layer 0=first, ... */
  912. NINT   var_idx;  /* Identifier of varibale within PE */
  913. NINT   rwf;      /* 0=read; 1=write */
  914. REAL   value;    /* value to assign (if write) */
  915. {
  916.   RPC_AREA_T *rpc;
  917.   ARGCNIO    *argcnio;
  918.  
  919.   rpc = &Data_transfer_ptr->RPC_area;
  920.   rpc->request = REQ_UG_CNIO;
  921.   argcnio = &rpc->all_arg_lists.argcnio;
  922.   argcnio->nlay = LayN;
  923.   argcnio->nPE = PEN;
  924.   argcnio->var_idx = var_idx;
  925.   argcnio->rwf = rwf;
  926.   argcnio->fweight = value;
  927.  
  928.   send_request_with_id();
  929.  
  930.   return((SREAL)rpc->return_value.buffer_real);
  931. }
  932.  
  933. InitGMenu( gmp, chrx, chry ) /* Initialize most menu params */
  934. GMENU *gmp;   /* Graphics menu pointer */
  935. int  chrx, chry;  /* character dimensions */
  936. {
  937.   GMENU_ITEM  *gmip;  /* Graphics menu item pointer */
  938.   int   wx; /* work index */
  939.   int   nmi;  /* number of menu items */
  940.   int   tsl;  /* total string length */
  941.   int   tpl;  /* total pixel length */
  942.   int   x0, y0, x1, y1, ytxt;
  943.   int   chrxover2; /* x margin */
  944.  
  945.   tsl = 0;
  946.   nmi = gmp->num_items;
  947.   /* Count total number of characters */
  948.   for (gmip = gmp->item, wx = 0; wx < nmi; gmip++, wx++ )
  949.     tsl += strlen( gmip->text );
  950.  
  951.   tpl = (nmi + tsl) * chrx + 1;
  952.   
  953.   /* Fill in item structures */
  954.   y0 = 1;
  955.   y1 = y0 + 2 * GM_MARGIN + chry - 1;
  956.   if ( (gmp->flag & GM_AUX) != 0 ) y1 += GM_MARGIN + chry;
  957.   ytxt = y1 - GM_MARGIN - chry;
  958.   chrxover2 = chrx / 2;
  959.   x0 = 1;
  960.   for (gmip = gmp->item, wx = 0; wx < nmi ; gmip++ , wx++) {
  961.     x1 = x0 + (1+strlen( gmip->text )) * chrx - 1;
  962.     gmip->x0 = x0;
  963.     gmip->x1 = x1;
  964.     gmip->y0 = y0;
  965.     gmip->y1 = y1;
  966.     /* text always aligned on character size boundary rel to start of menu */
  967.     gmip->xt = x0 + chrxover2;
  968.     gmip->yt = ytxt;
  969.     x0 = x1 + 2;
  970.     gmip->flag = 0x0000;
  971.   }
  972.  
  973.    gmp->x1 = x1 + 1;
  974.    gmp->y1 = y1 + 1;
  975. }
  976.  
  977.  
  978. DispGMenu( gmp )
  979. GMENU *gmp;   /* Graphics menu pointer */
  980. {
  981.   GMENU_ITEM  *gmip;  /* Graphics menu item pointer */
  982.   int   nmi;  /* number of menu items */
  983.   int   wx; /* work nint */
  984.   
  985.   /* Display outline */
  986.   nmi = gmp->num_items;
  987.  
  988.   for (gmip = gmp->item, wx = 0; wx < nmi; gmip++, wx++ )
  989.     ug_line( gmp->key, gm_outcolor, 0,
  990.        gmp->x0 + gmip->x0 - 1, gmp->y0,
  991.        gmp->x0 + gmip->x0 - 1, gmp->y0 + gmp->y1, 0 );
  992.  
  993.   ug_line( gmp->key, gm_outcolor, 0,
  994.      gmp->x0 + gmp->x1, gmp->y0,
  995.      gmp->x0 + gmp->x1, gmp->y0 + gmp->y1, 0 );
  996.  
  997.   /* Draw horizontal lines */
  998.   ug_line( gmp->key, gm_outcolor, 0,
  999.      gmp->x0, gmp->y0,
  1000.      gmp->x0 + gmp->x1, gmp->y0, 0 );
  1001.   ug_line( gmp->key, gm_outcolor, 0,
  1002.      gmp->x0, gmp->y0 + gmp->y1,
  1003.      gmp->x0 + gmp->x1, gmp->y0 + gmp->y1, 0 );
  1004.  
  1005.   for (gmip = gmp->item, wx = 0; wx < nmi; gmip++, wx++ ) {
  1006.     gmip->flag &= ~GM_HILITE; /* Unhighlight */
  1007.     DispGItem( gmp, gmip, gm_txtcolor, gm_intcolor );
  1008.   }
  1009. }
  1010.  
  1011.   
  1012. DispGItem( gmp, gmip, text_color, back_color )
  1013. GMENU   *gmp;   /* Graphics menu pointer */
  1014. GMENU_ITEM  *gmip;    /* Graphics menu item pointer */
  1015. int   text_color;
  1016. int   back_color;
  1017. {
  1018.   ug_boxf( gmp->key, back_color, 0,
  1019.      gmp->x0 + gmip->x0, gmp->y0 + gmip->y0,
  1020.      gmp->x0 + gmip->x1, gmp->y0 + gmip->y1 );
  1021.   ug_puts( gmp->key, text_color, 0,
  1022.      gmp->x0 + gmip->xt, gmp->y0 + gmip->yt, gmip->text, 0 );
  1023.   if ( (gmp->flag & GM_AUX) != 0 )
  1024.     ug_puts( gmp->key, text_color, 0,
  1025.        gmp->x0 + gmip->xt, gmp->y0 + gmip->y0 + GM_MARGIN - 1,
  1026.        gmip->text2, 0 );
  1027. }
  1028.  
  1029.  
  1030. GMENU_ITEM *LookGMenu( gmp , button ) /* returns item and button code */
  1031. GMENU *gmp;   /* Graphics menu pointer */
  1032. int *button;  /* returned button code */
  1033. {
  1034.   GMENU_ITEM  *gmip;  /* Graphics menu item pointer */
  1035.   GMENU_ITEM  *rgmip; /* Returned graphics menu item pointer */
  1036.   int   nmi;  /* Number of menu items */
  1037.   int   key, xp, yp;  /* for mouse call */
  1038.   int   wx; /* work nint */
  1039.  
  1040.   rgmip = (GMENU_ITEM *) 0;
  1041.   nmi = gmp->num_items;
  1042.   
  1043.   ug_mouse( &key, &xp, &yp, button );
  1044.   xp = xp - gmp->x0;
  1045.   yp = yp - gmp->y0;
  1046.   if ( key == gmp->key ) { /* Find item pointed to and highlight */
  1047.     for (gmip = gmp->item, wx = 0; wx < nmi; gmip++, wx++ ) {
  1048.       if ( xp >= gmip->x0 && xp <= gmip->x1 &&
  1049.      yp >= gmip->y0 && yp <= gmip->y1 &&
  1050.      rgmip == (GMENU_ITEM *)0 &&
  1051.      (gmip->flag & GM_LOCKED) == 0 )
  1052.       {
  1053.         if ( (gmip->flag & GM_HILITE) == 0) {
  1054.     gmip->flag |= GM_HILITE;
  1055.     DispGItem( gmp, gmip, gm_intcolor, gm_txtcolor ); /* highlight */
  1056.   }
  1057.   rgmip = gmip;
  1058.       } else if ( (gmip->flag & GM_HILITE) != 0) {
  1059.   gmip->flag &= ~GM_HILITE;
  1060.   DispGItem( gmp, gmip, gm_txtcolor, gm_intcolor ); /* Unhighlight */
  1061.       }
  1062.     }
  1063.   } else {  /* Unhilight any highlighted items */
  1064.     for (gmip = gmp->item, wx = 0; wx < nmi; gmip++, wx++ )
  1065.       if ( (gmip->flag & GM_HILITE) != 0) {
  1066.   gmip->flag &= ~GM_HILITE;
  1067.   DispGItem( gmp, gmip, gm_txtcolor, gm_intcolor ); /* Unhighlight */
  1068.       }
  1069.   }
  1070.  
  1071.   return( rgmip );
  1072. }
  1073.