home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / EDUCATON / INF_SRC.ARC / RUNROUTI.C < prev    next >
Encoding:
C/C++ Source or Header  |  1986-03-14  |  3.6 KB  |  179 lines
  1.  
  2.  
  3. /*****************************************************************
  4. **                                **
  5. **      Inference -- (C) Copyright 1985 George Hageman    **
  6. **                                **
  7. **        user-supported software:                **
  8. **                                **
  9. **            George Hageman                **
  10. **            P.O. Box 11234                **
  11. **            Boulder, Colorado 80302            **
  12. **                                **
  13. *****************************************************************/
  14.  
  15. /*****************************************************************
  16. **
  17. **    runRoutine(antecedent)
  18. **
  19. **    spawns the process with the path name specified in
  20. **
  21. **    ruleBuff[antecedent].string
  22. **
  23. **    and returns the value as TRUE or FALSE  depending on
  24. **    the value returned from the exit() command from the spawnd routine.
  25. **
  26. **    the routine returns TRUE if there is any problem with spawning
  27. **    the specified executable.
  28. **
  29. ******************************************************************/
  30. #define    MAX_ARGS    20
  31.  
  32. #include <stdio.h>
  33.  
  34. #ifdef MSDOS
  35. #include <process.h>
  36. #endif
  37.  
  38. #include <errno.h>
  39.  
  40. #include "expert.h"
  41. #include "inference.h"
  42. #include "routine.h"
  43.  
  44. int    runRoutine(cnsquent)
  45.     int    cnsquent ;
  46. {
  47. extern int errno ;
  48.  
  49. #ifdef UNIXSV
  50. int    pnid ;
  51. #endif
  52.  
  53. int    i,argc,p_value,numChars ;
  54. char    buffer[MAX_STR_LEN], *string_p;
  55. char    *argv[MAX_ARGS] ;
  56.  
  57. /*
  58. ** copy string to buffer to get parameters
  59. */
  60.  
  61. string_p = &strBuff[ruleBuff[cnsquent].string] ;
  62.  
  63. for (numChars = 0 ; numChars < MAX_STR_LEN ; numChars++)
  64.     {
  65.     buffer[numChars]= *( string_p + numChars ) ; 
  66.     if(buffer[numChars] == NULL)
  67.         break ;
  68.     }
  69.     
  70. #ifdef DEBUG
  71. printf("\nDEBUG -- runroutine -- copied string is %s\n",buffer) ;
  72. #endif
  73.  
  74. /*
  75. ** set the argv(alues) to the proper location within the buffer
  76. */
  77.  
  78. argc = 1 ;
  79. argv[0] = buffer ;
  80.  
  81. for(i=0;i<numChars;i++)
  82.     {
  83. #ifdef DEBUG
  84. printf("\n DEBUG -- runroutine parameters i = %d, char = %c \n",i,buffer[i]) ;
  85. #endif
  86.     if(buffer[i] == NULL)
  87.         {
  88.         break ;
  89.         }
  90.     if(buffer[i] == BLANK)
  91.         {
  92.         buffer[i] = NULL ;
  93.         while( buffer[++i] == BLANK ) ;
  94.         if(buffer[i] == NULL)
  95.             {
  96.             break ;
  97.             }
  98.         argv[argc++] = &buffer[i] ;
  99.         if(argc == MAX_ARGS)
  100.             {
  101.             printf("\n maximum arguments exceeded for %s\n",string_p);
  102.             argc -= 1 ;
  103.             break ;
  104.             }
  105.         }
  106.     }
  107. argv[argc]=NULL ;
  108. #ifdef DEBUG
  109. for( i = 0 ; i < argc ; i++)
  110.     {
  111.     printf("\n argv[%d] = %s\n",i,argv[i]) ;
  112.     }
  113.  
  114. printf("\nRunning Routine %s ",argv[0] ) ;
  115. #endif
  116.  
  117. #ifdef MSDOS
  118. p_value=spawnv(P_WAIT,argv[0],argv ) ;
  119. #endif
  120.  
  121.  
  122. #ifdef UNIXSV
  123. pnid = fork() ;
  124. if(pnid == -1)
  125.     {
  126.     printf("\nFork failure! Running %s -- returning TRUE \n",argv[0]) ;
  127.     return(TRUE) ;
  128.     }
  129. if(pnid != 0 )         /* parent */
  130.     {
  131.     wait(&p_value) ;
  132.     if(p_value != -1)
  133.         p_value = (p_value >> 8 ) & 0x0ff ;
  134.     }
  135. else            /* child */
  136.     {
  137.     execv(argv[0],argv) ;
  138.     }
  139. #endif
  140.  
  141. /*
  142. **    The return value is set by the routine having an exit(X)  where
  143. **    X is the value to be returned...
  144. **    There is a problem since the return value can also provide an
  145. **    indication that there was some problem with the attempt as follows:
  146. */
  147.  
  148. if(p_value == RETURN_ROUTINE_TRUE)
  149.     {
  150. #ifdef DEBUG
  151.     printf(" -- TRUE\n") ;
  152. #endif
  153.     return(TRUE) ;
  154.     }
  155. if(p_value == RETURN_ROUTINE_FALSE)
  156.     {
  157. #ifdef DEBUG
  158.     printf(" -- FALSE \n") ;
  159. #endif
  160.     return(FALSE) ;
  161.     }
  162. if(p_value)
  163.     switch(errno)
  164.         {
  165.         case ENOENT :
  166.             printf("\n Executable file %s not found assumed TRUE\n",argv[0]) ;
  167.             return(TRUE) ;
  168.         case ENOEXEC :
  169.             printf("\n File %s is not executable assumed TRUE\n",argv[0]) ;
  170.             return(TRUE) ;
  171.         case ENOMEM :
  172.             printf("\ Not enough memory to run -- assumed TRUE\n") ;
  173.             return(TRUE) ;
  174.         }    
  175. printf("\n Routine did not return either ROUTINE_TRUE or ROUTINE_FALSE assumed TRUE\n") ;
  176. return(TRUE) ;
  177. }
  178.  
  179.