/***********************************************************
*                   Term accses methods                    *
************************************************************
* Description:                                             *
*                                                          *
* Created by: avrami tzur                                  *
* At: Fri Jul 24 08:59:53 1992                             *
***********************************************************/

/* INCLUDES */
#include "structures.h"


/* DECLERATIONS */
int GetTermFunctor(term_pointer term);
char *GetTermString(term_pointer term);
int *GetTermValue(term_pointer term);
term_pointer GetTermArgument(term_pointer term, int arg_num);


char *TermToString(term_pointer term);
static char *CreateTermString(term_pointer term, char *buff);
static char * gatherList(term_pointer ptr, char *buff);

/*
============================================================
|                      GetTermFunctor()                    |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
int GetTermFunctor(term_pointer term)
{
   return((term->term_type == NONVAR)?term->functor:-1);
}




/*
============================================================
|                      GetTermString()                     |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
char *GetTermString(term_pointer term)
{
   char *str = NULL;
   int len;

   if(term->term_type == STRING) {
      /* The term is a string. */
      len = strlen(term->const_string)+1;
      str = (char *)malloc((len = strlen(term->const_string)+1));
      strncpy(str, term->const_string, len);
   }
   return(str); 
}



/*
============================================================
|                      GetTermValue()                      |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
int *GetTermValue(term_pointer term)
{
   int *value = NULL;

   if(term->term_type == INTEGER) {
      /* The term is an integer. */
      value = (int *)malloc(sizeof(int));
      *value = term->functor;
   }
   return(value); 
}


/*
============================================================
|                     GetTermArgument()                    |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
term_pointer GetTermArgument(term_pointer term, int arg_num)
{
   /* term must be of type NONVAR or TUPLE. */
   if((term->term_type != NONVAR) && (term->term_type != TUPLE)) return(NULL);
   else {
      if(term->arity <= arg_num) return(NULL);
      else return(term->argument_array[arg_num]);
   }
}





/*
============================================================
|                      TermToString()                      |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
char *TermToString(term_pointer term)
{
   char buffer[500];
   char *b1 = buffer;
   char *ret;
   int length;
   b1 = CreateTermString(term, buffer);
   length = b1-buffer;
   ret = (char *)malloc(length+2);
   memcpy((void *)ret,(void *)buffer,length);
   ret[length] = '.';
   ret[length+1] = '\0';
   return(ret);
}


/*
============================================================
|                    CreateTermString()                    |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
static char *CreateTermString(term_pointer ptr, char *buff)
{
  int i;
  int length;


  switch(ptr->term_type){
    case VARIABLE:{
#ifdef SYSV
       length = sprintf(buff, "V%d", ptr->functor);
       buff += length;
#else  /* BSD unix */
       sprintf(buff, "V%d", ptr->functor);
       buff += strlen(buff);
#endif
       break;
    }
     case NONVAR: {
        switch (ptr->functor)
        {
        case EMPTY_LIST:
           sprintf(buff,"[]");
           buff += 2;
           break;
        case CONS_LIST:
           buff = gatherList(ptr,buff);
           break;
        default:
#ifdef SYSV
           length = sprintf(buff,"%s", sym_table[ptr->functor]->name);
           buff += length;
#else
           sprintf(buff,"%s", sym_table[ptr->functor]->name);
           buff += strlen(buff);
#endif
           if(ptr->arity != 0) { *buff = '('; buff++;}
           for(i=0; i<ptr->arity; i++){
              buff = CreateTermString(ptr->argument_array[i],buff);
              if(i  == ptr->arity-1) {*buff = ')', buff++;}
              else {*buff = ',';buff++;}
           }
        }
        break;
     }
    case INTEGER:{
#ifdef SYSV
       length = sprintf(buff, "%d", ptr->functor);
       buff += length;
#else
       sprintf(buff, "%d", ptr->functor);
       buff += strlen(buff);
#endif
       break;
    }
    case TUPLE:{
       *buff = '<';buff++;
       for(i=0; i<ptr->arity; i++){
          buff = CreateTermString(ptr->argument_array[i],buff);
          if(i  == ptr->arity-1) {*buff = '>';buff++;}
          else {*buff = ',';buff++;}
       }
       break;
    }
    case STRING:{
#ifdef SYSV
       length = sprintf(buff,"%c%s%c", '"', ptr->const_string, '"');
       buff += length;
#else
       sprintf(buff,"%c%s%c", '"', ptr->const_string, '"');
       buff += strlen(buff);
#endif
       break;
    }
  }

  return(buff);
}

/*case NONVAR:{
#ifdef SYSV
       length = sprintf(buff,"%s", sym_table[ptr->functor]->name);
       buff += length;
#else
       sprintf(buff,"%s", sym_table[ptr->functor]->name);
       buff += strlen(buff);
#endif
       if(ptr->arity != 0) { *buff = '('; buff++;}
       for(i=0; i<ptr->arity; i++){
          buff = CreateTermString(ptr->argument_array[i],buff);
          if(i  == ptr->arity-1) {*buff = ')', buff++;}
          else {*buff = ',';buff++;}
       }
       break;
    } */    


/*
============================================================
|                       gatherList()                       |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
| Created by: Avrami Tzur                                  |
| At: Mon Oct 12 12:49:19 1992                             |
|==========================================================|
*/
static char * gatherList(term_pointer ptr, char *buff)
{
   *buff = '[';buff++;
   while (ptr->functor==CONS_LIST)
   { 
      buff = CreateTermString(ptr->argument_array[0],buff);
      ptr = ptr->argument_array[1];
      if (ptr->functor == CONS_LIST) {
         *buff = ',';buff++;
      }
   }
   if (ptr->functor != EMPTY_LIST) 
   {
      *buff = '|'; buff++;
      buff = CreateTermString(ptr,buff);
   }
   sprintf(buff,"]");buff++;
   return(buff);
}