Esempio n. 1
0
/*
 * Changes the size of the buffer to contain at least newsize bytes 
 */
void change_buffer_size(const size_t newsize) {
  if ( BUFFER_PTR == NULL )
    {
      if ((BUFFER_PTR = malloc(  BLOCK_SIZE < newsize ? newsize : BLOCK_SIZE)) == NULL) {
        YAP_Error(0,0,"Prolog2Term: Out of memory.\n");
#ifdef MPI
        MPI_Finalize();
#endif
        YAP_Exit( 1 );
      }
    }
  else if ((BUFFER_SIZE>=BLOCK_SIZE &&
       BUFFER_SIZE>=newsize) )
    {
      return;
    }
  else if ((BUFFER_PTR = realloc( BUFFER_PTR, newsize)) == NULL) {
    YAP_Error(0,0,"Prolog2Term: Out of memory.\n");
#ifdef MPI
    MPI_Finalize();
#endif
    YAP_Exit( 1 );
  }
  BUFFER_SIZE=newsize;
}
Esempio n. 2
0
/* execute a command as a detached process */
static YAP_Bool do_shell(void) {
#if defined(__MINGW32__) || _MSC_VER
  YAP_Error(0, 0L, "system not available in this configuration");
  return (FALSE);
#elif HAVE_SYSTEM
  char *buf = YAP_AllocSpaceFromYap(BUF_SIZE);
  int sys;

  if (buf == NULL) {
    YAP_Error(0, 0L, "No Temporary Space for Shell");
    return (FALSE);
  }
#if HAVE_STRNCPY
  strncpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1)), BUF_SIZE);
  strncpy(buf, " ", BUF_SIZE);
  strncpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2)), BUF_SIZE);
  strncpy(buf, " ", BUF_SIZE);
  strncpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)), BUF_SIZE);
#else
  strcpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1)));
  strcpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2)));
  strcpy(buf, " ");
  strcpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)));
#endif
  sys = system(buf);
  YAP_FreeSpaceFromYap(buf);
  if (sys < 0) {
    return YAP_Unify(YAP_ARG5, YAP_MkIntTerm(errno));
  }
  return YAP_Unify(YAP_ARG4, YAP_MkIntTerm(sys));
#else
  char *cptr[4];
  int t;
  int sys;

  cptr[0] = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
  cptr[1] = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2));
  cptr[2] = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3));
  cptr[3] = NULL;
  t = fork();
  if (t < 0) {
    return YAP_Unify(YAP_ARG5, YAP_MkIntTerm(errno));
  } else if (t == 0) {
    t = execvp(cptr[0], cptr);
    return t;
  } else {
    t = wait(&sys);
    if (t < 0) {
      return YAP_Unify(YAP_ARG5, YAP_MkIntTerm(errno));
    }
  }
  return YAP_Unify(YAP_ARG4, YAP_MkIntTerm(sys));
#endif
}
Esempio n. 3
0
/* return YAP's environment */
static YAP_Bool p_environ(void) {
#if HAVE_ENVIRON && 0
#if HAVE__NSGETENVIRON
  char **ptr = _NSGetEnviron();
#elif defined(__MINGW32__) || _MSC_VER
  extern char **_environ;
  char **ptr = _environ;
#else
  extern char **environ;
  char **ptr = environ;
#endif
  YAP_Term t1 = YAP_ARG1;
  long int i;

  i = YAP_IntOfTerm(t1);
  if (ptr[i] == NULL)
    return (FALSE);
  else {
    YAP_Term t = YAP_BufferToString(ptr[i]);
    return (YAP_Unify(t, YAP_ARG2));
  }
#else
  YAP_Error(0, 0L, "environ not available in this configuration");
  return (FALSE);
#endif
}
Esempio n. 4
0
/*
 * Read a prolog term from a stream
 * (the prolog term must have been writen by the write_term_to_stream)
 */
YAP_Term 
read_term_from_stream(const int fd) {
  size_t size; 

  RESET_BUFFER();    
  if (!read(fd,(void*)&size,sizeof(size_t))) { // read the size of the term
    YAP_Error(0,0,"Prolog2Term: IO error in read.\n");
  }
#ifdef DEBUG
  write_msg(__FUNCTION__,__FILE__,__LINE__,"read_term_from_stream>>>>size:%d\n",size);  
#endif
  if ( size> BUFFER_SIZE)
    expand_buffer(size-BUFFER_SIZE);
  if (!read(fd,BUFFER_PTR,size)) {
    YAP_Error(0,0,"Prolog2Term: IO error in read.\n");
  };            // read term from stream
  return YAP_ImportTerm( BUFFER_PTR);
}
Esempio n. 5
0
/*
 * Writes a term to a stream.
 */
size_t 
write_term_to_stream(const int fd,const YAP_Term term) {

  RESET_BUFFER();
  printf("BUFFER_PTR=%p\n", BUFFER_PTR);
  p2c_putt(term);
  if (write(fd,(void*)BUFFER_PTR,BUFFER_LEN) < 0) {     // write term
    YAP_Error(0,0,"Prolog2Term: IO error in write.\n");
    return -1;
  }
  return BUFFER_LEN;
}
Esempio n. 6
0
/*
 * Adds 'space' to the size of the currently allocated buffer
 */
static void
expand_buffer(const size_t space ) {
  BUFFER_PTR = realloc( BUFFER_PTR, BUFFER_SIZE + space );
  if( BUFFER_PTR == NULL ) {
    YAP_Error(0,0,"Prolog2Term: Out of memory.\n");
#ifdef MPI
    MPI_Finalize();
#endif
    YAP_Exit( 1 );
  }
  BUFFER_SIZE+=space;
}
Esempio n. 7
0
static int init_standard_system(int argc, char *argv[], YAP_init_args *iap) {

  YAP_file_type_t BootMode = YAP_parse_yap_arguments(argc, argv, iap);

  /* init memory */
  iap->initial_file_type =
    BootMode = YAP_Init(iap);
  if (iap->ErrorNo) {
    /* boot failed */
    YAP_Error(iap->ErrorNo, 0L, iap->ErrorCause);
  }
  return BootMode;
}
Esempio n. 8
0
/** @pred  system(+ _S_)

Passes command  _S_ to the Bourne shell (on UNIX environments) or the
current command interpreter in WIN32 environments.

Note that it executes them command as a detached process. It requires
`system` to be implemented by the system library.

*/
static YAP_Bool do_system(void) {
  char *command = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
#if HAVE_SYSTEM
  int sys = system(command);
  if (sys < 0) {
    return YAP_Unify(YAP_ARG3, YAP_MkIntTerm(errno));
  }
  return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(sys));
#else
  YAP_Error(0, 0L, "system not available in this configuration, trying %s",
            command);
  return FALSE;
#endif
}
Esempio n. 9
0
/*
 * Changes the size of the buffer to contain at least newsize bytes 
 */
void
change_buffer_size(const size_t newsize) {

  if ( BUFFER_SIZE>=BLOCK_SIZE && BUFFER_SIZE>newsize)
    return;
  if(BUFFER_PTR!=NULL)
    free(BUFFER_PTR);
  BUFFER_PTR = (char*)malloc(newsize);
  if( BUFFER_PTR == NULL ) {
    YAP_Error(0,0,"Prolog2Term: Out of memory.\n");
#ifdef MPI
    MPI_Finalize();
#endif
    YAP_Exit( 1 );
  }
  BUFFER_SIZE=newsize;
}
Esempio n. 10
0
/*
 * Adds 'space' to the size of the currently allocated buffer
 */
static void
expand_buffer(const size_t space ) {
  char *oldblock;
  
  // BUFFER_PTR = realloc( BUFFER_PTR, BUFFER_SIZE + space );
  oldblock= BUFFER_PTR;
  BUFFER_PTR = (char*)malloc( BUFFER_SIZE + space );
  if( BUFFER_PTR == NULL ) {
    YAP_Error(0,0,"Prolog2Term: Out of memory.\n");
#ifdef MPI
    MPI_Finalize();
#endif
    YAP_Exit( 1 );
  }
  memcpy(BUFFER_PTR,oldblock,BUFFER_SIZE);

  if(oldblock!=NULL)
    free(oldblock);
	   
  BUFFER_SIZE+=space;
}
Esempio n. 11
0
static int
init_standard_system(int argc, char *argv[], YAP_init_args *iap)
{
  int BootMode;

  BootMode = YAP_parse_yap_arguments(argc,argv,iap);

  /* init memory */
  if (BootMode == YAP_BOOT_FROM_PROLOG ||
      BootMode == YAP_FULL_BOOT_FROM_PROLOG) {
    int NewBootMode = YAP_Init(iap);
    if (NewBootMode != YAP_BOOT_FROM_PROLOG && BootMode != YAP_FULL_BOOT_FROM_PROLOG)
      BootMode = NewBootMode;
  } else {
    BootMode = YAP_Init(iap);
  }
  if (iap->ErrorNo) {
    /* boot failed */
    YAP_Error(iap->ErrorNo,0L,iap->ErrorCause);
  }
  return BootMode;
}