// Author : Gregory R. Olsen 
//          Center for Design Research, Stanford University
//          560 Panama Street
//          Stanford, CA 94305-2232
//          olsen@cs.stanford.edu
// Contributions by: Jim McGuire (Lockheed AI Center)

// Copyright (c) 1993 Stanford University. All rights reserved.
// Copyright (c) 1993 Lockheed Missiles and Space Co.

/*
 * Permission is hereby granted, without written agreement and without
 * license, to use, copy, modify, and distribute this software and its 
 * documentation for non-commercial use, provided that the above 
 * copyright notice and the following two paragraphs appear in
 * all copies of this software.
 * 
 * THIS SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
 * 
 * IN NO EVENT SHALL STANFORD UNIVERSITY OR LOCKHEED MISSILES AND SPACE 
 * COMPANY BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR 
 * CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER 
 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED
 * OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING 
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */


#include "KIFClass.h"
#include <stdlib.h>

// Strings Corresponding to Integer Identifiers of KIF classes
static char *TypeNames[] = {
  "EXPRESSION", "SENTENCE", "TERM", "NODE", "LIST", "WORD", "CONSIS_",
  "OBJECTDEF", "FUNCTIONDEF", "RELATIONDEF", "CONSTANT_", "INDVAR_",
  "NUMBER_", "STRING_", "FUNCONST", "RELCONST", "OBJCONST", "SEQVAR_",
  "LISTTERM", "SETTERM", "QUOTERM", "LOGTERM", "IFTERM", "FUNCTERM", 
  "EQUATION", "CONJUNCTION", "DISJUNCTION", "IMPLICATION",
  "EQUIVALENCE", "QUANTSENT", "UNIVERSENT", "EXISTENSENT", "RELSENT", 
  "LOGCONST", "KIFOPERATOR", "TERMOP","SENTOP", "DEFOP", "INEQUALITY",
  "NEGATION", "RULEOP", "RULE", "SETOFALLTERM",
  "KIFOBJ", "SEQUENCE", "KIFNULLOBJ", "UKCONST"
};

char *typeName(kifobj *obj)
{
  if (obj!=NULL)
    return(TypeNames[obj->type()]);
  else
    return("NULL");
}

// Initialize Null Marker

const kifnullobj *kifobj::nullmarker = new kifnullobj();

// KIF Related Help Functions
//

////////////////////////////////////////////
/* 
  FUNCTION: listprint
  ABSTRACT: Function to parenthesize string representation
            of KIF objects.
*/
char *listprint(char *s) 
{
  char *strng;
  if (s!=NULL) {
    strng = (char *) malloc((unsigned) strlen(s)+3);
    sprintf(strng,"(%s)",s);
   delete s;
  }
  else
    strng = strdup("()");

  return strng;
};

////////////////////////////////////////////
/* 
 FUNCTION: append
 ABSTRACT: Function to create a sequence of KIF string
 representations separated by a space.
 */
char *append(char *s1, char *s2)
{
  char *strng;
  if (s1!=NULL && s2!=NULL && *s1!='\0' && *s2!='\0') {
    strng = (char *) malloc((unsigned) strlen(s1)+strlen(s2)+2);
    sprintf(strng,"%s %s",s1,s2);
    delete s1;
    delete s2;
  }
  else if (s1!=NULL && *s1!='\0') {
    strng = s1;
    delete s2;
  }
  else if (s2!=NULL && *s2!='\0') {
    strng = s2;
    delete s1;
  }
  else {
    strng = strdup("");
    delete s1;
    delete s2;
  }
  
  return strng;
};

////////////////////////////////////////////
/* 
  FUNCTION: seqappend
  ABSTRACT: Function to append two sequences.
*/
sequence *seqappend(sequence *seq1,sequence *seq2)
{
  if (seq1 == kifobj::nullmarker)
    return(seq2);
  else if (seq2 != kifobj::nullmarker) {
    sequence *tmpseq = seq1;
    while (tmpseq->tl() != kifobj::nullmarker) 
      tmpseq = tmpseq->tl();
    tmpseq->changetail(seq2);
  }
  return(seq1);
}

//---------------------------------------------------------------------------------
//                                  SEQUENCE::ADD
//---------------------------------------------------------------------------------

////////////////////////////////////////////
/* 
  FUNCTION: sequence::add
  ABSTRACT: Function to add an expression to a sequence.
*/
void sequence::add(expression *e)
{
  if (head == nullmarker) 
    head = e;
  else {
    sequence *t = new sequence(e);
    sequence *s = this;
    while (s->tl() != nullmarker) 
      s = s->tl();
    s->changetail(t);}
}

//---------------------------------------------------------------------------------
//                                  ::KIFSTRING
//---------------------------------------------------------------------------------

//////////////////////////////////////////////////////
/* 
  VIRTUAL FUNCTION: expression::kifstring(void)
  ABSTRACT: Function to generate a character representation
            of a KIF expression object.
*/

// sequence    //////////////////////////
char * sequence::kifstring(void)
{
  return append(hd()->kifstring(),
		(tl()!=nullmarker)?tl()->kifstring():NULL);
}

//   list      //////////////////////////
char * list::kifstring(void)
{
  return listprint(content()->kifstring());
}

//  word     //////////////////////////
char * word::kifstring(void)
{
  return ((val!=NULL)?strdup(val):NULL);
}

//  constant   //////////////////////////
char * constant::kifstring(void)
{
  return ((con!=NULL)?strdup(con):NULL);
}

//  string   //////////////////////////
char * string::kifstring(void)
{
  char *tmp;
  tmp = (char *) malloc((unsigned) strlen(con)+3);
  sprintf(tmp,"\"%s\"",con);
  return tmp;
}

//   listerm   //////////////////////////
char * listterm::kifstring(void)
{
  char *lt_s;
  lt_s = (char *)malloc((sizeof(char) * (strlen("LISTOF")+1)));
  strcpy(lt_s,"LISTOF");
  return listprint(append(lt_s,
			  terms()->kifstring()));
}

//   setterm   //////////////////////////
char * setterm::kifstring(void)
{
  char *st_s;
  st_s = (char *)malloc((sizeof(char) * (strlen("SETOF")+1)));
  strcpy(st_s,"SETOF");
  return
    listprint(append(st_s, terms()->kifstring()));
}

//   quoterm   //////////////////////////
char * quoterm::kifstring(void)
{
  char *qt_s;
  qt_s = (char *)malloc((sizeof(char) * (strlen("QUOTE")+1)));
  strcpy(qt_s,"QUOTE");
  return listprint(append(qt_s, express()->kifstring()));
}

//   ifterm   //////////////////////////
char * ifterm::kifstring(void)
{
	char *if_s;
	if_s = (char *)malloc((sizeof(char) * (strlen("IF")+1)));
	strcpy(if_s,"IF");
	if (elsepart()) {
	     return listprint(append(
			  append(if_s,testpart()->kifstring()),
			  append(thenpart()->kifstring(),
				 elsepart()->kifstring())
			  ));
	}
	else {
	     return listprint(append(
			  append(if_s,testpart()->kifstring()),
			  thenpart()->kifstring()
			  ));
	}
}

//  functerm    //////////////////////////
char * functerm::kifstring(void)
{
  return listprint(append(func()->kifstring(),
			  terms()->kifstring()));
}

//  equation    //////////////////////////
char * equation::kifstring(void)
{
  char *eq_s;
  eq_s = (char *)malloc((sizeof(char) * (strlen("=")+1)));
  strcpy(eq_s,"=");
  return listprint(append(eq_s,
			  append(lhs()->kifstring(),
				 rhs()->kifstring())));
}

//  equation    //////////////////////////
char * setofallterm::kifstring(void)
{
  char *eq_s;
  eq_s = (char *)malloc((sizeof(char) * (strlen("setofall")+1)));
  strcpy(eq_s,"setofall");
  return listprint(append(eq_s,
			  append(target()->kifstring(),
				 setof_sentence()->kifstring())));
}

//  inequality   //////////////////////////
char * inequality::kifstring(void)
{
  char *eq_s;
  eq_s = (char *)malloc((sizeof(char) * (strlen("/=")+1)));
  strcpy(eq_s,"/=");
  return listprint(append(eq_s,
			  append(lhs()->kifstring(),
				 rhs()->kifstring())));
}

//  negation    //////////////////////////
char * negation::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("NOT")+1)));
  strcpy(n_s,"NOT");
  return listprint(append(n_s,sent()->kifstring()));
}

//  conjunction   //////////////////////////
char * conjunction::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("AND")+1)));
  strcpy(n_s,"AND");
  return listprint(append(n_s,sents()->kifstring()));
}

//  disjunction   //////////////////////////
char * disjunction::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("OR")+1)));
  strcpy(n_s,"OR");
  return listprint(append(n_s,sents()->kifstring()));
}

//  implication   //////////////////////////
char * implication::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("=>")+1)));
  strcpy(n_s,"=>");
  return listprint(append(n_s,
			  append(antecedent()->kifstring(),
				 consequent()->kifstring())));
}

//  equivalence   //////////////////////////
char * equivalence::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("<=>")+1)));
  strcpy(n_s,"<=>");
  return listprint(append(n_s,
			  append(lhss()->kifstring(),
				 rhss()->kifstring())));
}

//  universent   //////////////////////////
char * universent::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("FORALL")+1)));
  strcpy(n_s,"FORALL");
  return listprint(append(n_s,
			  append(listprint(varlist()->kifstring()),
				 sent()->kifstring())));
}

//  existensent  //////////////////////////
char * existensent::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("EXISTS")+1)));
  strcpy(n_s,"EXISTS");
  return listprint(append(n_s,
			  append(listprint(varlist()->kifstring()),
				 sent()->kifstring())));
}

//  relsent    //////////////////////////
char * relsent::kifstring(void)
{
  return listprint(append(relation()->kifstring(),
			  terms()->kifstring()));
}

//  logconst   //////////////////////////
char * logconst::kifstring(void)
{
  return (value()) ? strdup("TRUE") : strdup("FALSE");
}

//  consis     //////////////////////////
char * consis::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("CONSIS")+1)));
  strcpy(n_s,"CONSIS");
  return listprint(append(n_s,sent()->kifstring()));
}

//  objectdef   //////////////////////////
char * objectdef::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("DEFOBJECT")+1)));
  strcpy(n_s,"DEFOBJECT");
  char *ceq_s;
  ceq_s = (char *)malloc((sizeof(char) * (strlen(":=")+1)));
  strcpy(ceq_s,":=");
  if (rhs()) {
	  return listprint(append(n_s,
				  append(object()->kifstring(),
					 append(ceq_s,rhs()->kifstring()))));
  }
  else {
    return listprint(append(n_s,object()->kifstring()));
  }
}

//  functiondef  //////////////////////////
char * functiondef::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("DEFFUNCTION")+1)));
  strcpy(n_s,"DEFFUNCTION");
  char *ceq_s;
  ceq_s = (char *)malloc((sizeof(char) * (strlen(":=")+1)));
  strcpy(ceq_s,":=");
  if (rhs()) {
    return listprint(append(n_s,
			    append(func()->kifstring(),
				   append(listprint(varlist()->kifstring()),
					  append(ceq_s,rhs()->kifstring())))));
  }
  else {
    return listprint(append(n_s,
			    append(func()->kifstring(),
				   listprint(varlist()->kifstring()))));
  }
}

//  relationdef   //////////////////////////
char * relationdef::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("DEFRELATION")+1)));
  strcpy(n_s,"DEFRELATION");
  char *ceq_s;
  ceq_s = (char *)malloc((sizeof(char) * (strlen(":=")+1)));
  strcpy(ceq_s,":=");
  if (rhs()) {
    return listprint(
		     append(n_s,
			    append(relation()->kifstring(),
				   append(listprint(varlist()->kifstring()),
					  append(ceq_s,
						 rhss()->kifstring())))));
  }
  else {
    return listprint(
		     append(n_s,
			    append(relation()->kifstring(),
				   listprint(varlist()->kifstring()))));
  }
}

//  rule   //////////////////////////
char * rule::kifstring(void)
{
  char *n_s;
  n_s = (char *)malloc((sizeof(char) * (strlen("=>>")+1)));
  strcpy(n_s,"=>>");
  return listprint(append(n_s,
			  append(antecedent()->kifstring(),
				 consequent()->kifstring())));
}