home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / Programming / Source / Gopher_1.12 / StuartSpeaker.m < prev    next >
Encoding:
Text File  |  1992-03-16  |  5.3 KB  |  257 lines
  1.     /*
  2.       Copyright (c) 1990, Scott Hess.  No rights reserved.  No
  3.       warrenty is provided for this software, neither explicit
  4.       nor implied.  The source and object code for this file
  5.       may be used and modified as the user sees fit.
  6.     */
  7.  
  8. #import <appkit/Listener.h>
  9. #import "StuartSpeaker.h"
  10. #import <mach.h>
  11. #import <sys/message.h>
  12. #import <servers/netname.h>
  13. #import <string.h>
  14. #import <stdio.h>
  15. #import <stdlib.h>
  16. #import <math.h>
  17. #import <libc.h>
  18.  
  19. extern port_t name_server_port;
  20. extern id NXResponsibleDelegate();
  21.  
  22. @implementation  StuartSpeaker :Speaker
  23. {
  24.   int nDefaults;        // The number of defaults.
  25.   StuartDefault *defaults;    // defaults/values for the new Stuart.
  26.   
  27.   BOOL activate;        // activate Stuart when we call?
  28.   char *host;            // host to run on.
  29. }
  30.  
  31. + new
  32. {
  33.   self=[super new];
  34.   nDefaults=0;
  35.   defaults=NULL;
  36.   host=NULL;
  37.   activate=YES;
  38.   return self;
  39. }
  40. - free
  41. {
  42.   free( defaults);
  43.   return [super free];
  44. }
  45.  
  46. -(int)_stuartNew:(char *)defs activate:(int)flag
  47. {
  48.   return [self selectorRPC:"_stuartNew:activate:" paramTypes:"ci", defs, flag];
  49. }
  50.  
  51. -(int)_stuartGet:(char **)defs
  52. {
  53.   return [self selectorRPC:"_stuartGet:" paramTypes:"C", defs];
  54. }
  55.  
  56. static const char *sValue;        // a temp variable.
  57.  
  58. static char buffer[ 1024];
  59.  
  60. const char *itoa( int i)
  61. {
  62.   sprintf( buffer, "%d", i);
  63.   return buffer;
  64. }
  65. const char *ftoa( float f)
  66. {
  67.   sprintf( buffer, "%f", f);
  68.   return buffer;
  69. }
  70. const char *btoa( BOOL b)
  71. {
  72.   sprintf( buffer, "%s", b ? "YES" : "NO");
  73.   return buffer;
  74. }
  75. BOOL atob( const char *s)
  76. {
  77.   if( !strcmp( s, "YES"))
  78.     return YES;
  79.   else if( !strcmp( s, "NO"))
  80.     return NO;
  81.   else
  82.     return atoi( s);
  83. }
  84.  
  85. -(const char *)default:(const char *)name
  86. {
  87.   int i=nDefaults;
  88.   while( i--)
  89.     if( !strcmp( defaults[ i].defName, name))
  90.       return defaults[ i].defValue;
  91.   return NULL;
  92. }
  93. -(int)defaultAsInt:(const char *)name
  94. {
  95.   return (sValue=[self default:name]) ? atoi( sValue) : 0;
  96. }
  97. -(float)defaultAsFloat:(const char *)name
  98. {
  99.   return (sValue=[self default:name]) ? atof( sValue) : NAN;
  100. }
  101. -(BOOL)defaultAsBOOL:(const char *)name
  102. {
  103.   return (sValue=[self default:name]) ? atob( sValue) : NO;
  104. }
  105. - default:(const char *)name as:(const char *)value
  106. {
  107.   int i=nDefaults;
  108.   while( i--)
  109.     if( !strcmp( defaults[ i].defName, name))
  110.       {
  111.         defaults[ i].defValue=realloc( defaults[ i].defValue, strlen( value)+1);
  112.     strcpy( defaults[ i].defValue, value);
  113.     return self;
  114.       }
  115.   defaults=realloc( defaults, (++nDefaults)*sizeof( struct _StuartDefault));
  116.   defaults[ nDefaults-1].defValue=malloc( strlen( value)+1);
  117.   strcpy( defaults[ nDefaults-1].defValue, value);
  118.   defaults[ nDefaults-1].defName=malloc( strlen( name)+1);
  119.   strcpy( defaults[ nDefaults-1].defName, name);
  120.   return self;
  121. }
  122. - default:(const char *)name asInt:(int)value
  123. {
  124.   return [self default:name as:itoa( value)];
  125. }
  126. - default:(const char *)name asFloat:(float)value
  127. {
  128.   return [self default:name as:ftoa( value)];
  129. }
  130. - default:(const char *)name asBOOL:(BOOL)value
  131. {
  132.   return [self default:name as:btoa( value)];
  133. }
  134.  
  135. -(int)stuartNew
  136. {
  137.   int i, size=0;
  138.   char *defs, *pos;
  139.   for( i=nDefaults; i--;)
  140.     size+=strlen( defaults[ i].defName)+strlen( defaults[ i].defValue)+2;
  141.   pos=defs=malloc( size+1);
  142.   for( i=nDefaults; i--;)
  143.     {
  144.       strcpy( pos, defaults[ i].defName);
  145.       strcat( pos, "=");
  146.       strcat( pos, defaults[ i].defValue);
  147.       pos+=strlen( pos);
  148.       *pos++='\n';
  149.     }
  150.   *pos++=0;            // double-null at the end.
  151.   i=[self _stuartNew:defs activate:activate];
  152.   free( defs);
  153.   return i;
  154. }
  155. -(int)stuartGet
  156. {
  157.   int i, len;
  158.   char *defs, *pos;
  159.   i=[self _stuartGet:&defs];
  160.   if( i)
  161.     return i;
  162.   while( *defs)
  163.     {
  164.       if( pos=index( defs, '='))
  165.         {
  166.       *pos++=0;
  167.       [self default:defs as:pos];
  168.       *--pos='=';
  169.     }
  170.       else
  171.         [self default:defs as:""];
  172.       defs+=strlen( defs)+1;
  173.     }
  174.   return 0;
  175. }
  176. -(int)stuartSend:(int)fd
  177. {
  178.   NXStream *s=NXOpenMemory( NULL, 0, NX_WRITEONLY);
  179.   char buffer[ 1024];
  180.   int ret, len;
  181.   char *buf;
  182.   while( (ret=read( fd, buffer, 1024))>0)
  183.     NXWrite( s, buffer, ret);
  184.   NXPutc( s, 0);
  185.   NXGetMemoryBuffer( s, &buf, &len, &ret);
  186.   ret=[self _stuartNew:buf activate:activate];
  187.   NXCloseMemory( s, NX_FREEBUFFER);
  188.   return ret;
  189. }
  190. -(int)stuartConnectAndNew
  191. {
  192.   int ret=-1;
  193.   port_t stuartPort=NXPortFromName( "Stuart", host);
  194.   if( stuartPort!=PORT_NULL)
  195.     {
  196.       [self setSendPort:stuartPort];
  197.       ret=[self stuartNew];
  198.       port_deallocate( task_self(), stuartPort);
  199.     }
  200.   else
  201.     fprintf( stderr, "Stuart not running\n");
  202.   return ret;
  203. }
  204. -(int)stuartConnectAndGet
  205. {
  206.   int ret=-1;
  207.   port_t stuartPort=NXPortFromName( "Stuart", host);
  208.   if( stuartPort!=PORT_NULL)
  209.     {
  210.       [self setSendPort:stuartPort];
  211.       ret=[self stuartGet];
  212.       port_deallocate( task_self(), stuartPort);
  213.     }
  214.   else
  215.     fprintf( stderr, "Stuart not running\n");
  216.   return ret;
  217. }
  218. -(int)stuartConnectAndSend:(int)fd
  219. {
  220.   int ret=-1;
  221.   port_t stuartPort=NXPortFromName( "Stuart", host);
  222.   if( stuartPort!=PORT_NULL)
  223.     {
  224.       [self setSendPort:stuartPort];
  225.       ret=[self stuartSend:fd];
  226.       port_deallocate( task_self(), stuartPort);
  227.     }
  228.   else
  229.     fprintf( stderr, "Stuart not running\n");
  230.   return ret;
  231. }
  232.  
  233. -(BOOL)activate
  234. {
  235.   return activate;
  236. }
  237. - setActivate:(BOOL)flag
  238. {
  239.   activate=flag;
  240.   return self;
  241. }
  242. -(const char *)host
  243. {
  244.   return host;
  245. }
  246. - setHost:(const char *)h
  247. {
  248.   if( h==NULL)
  249.     free( host), host=NULL;
  250.   else
  251.     host=strcpy( realloc( host, strlen( h)+1), h);
  252.   return self;
  253. }
  254.  
  255. @end
  256.  
  257.