#ifndef KIFCLASS_H
#define KIFCLASS_H

// 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.
 */

// KIF expression class hierarchy
//
#define MAXMESLEN 1024
#define MAX_WORD 80

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

// Integer Identifiers of KIF classes
enum {EXPRESSION=0, 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};

// Prototypes
class kifobj;
class expression;
class form;
class sequence;
class kifoperator;
class defop;
class ruleop;
class sentop;
class termop;
class seqvar;
class ukconst;
class term;
class sentence;
class definition;
class objectdef;
class functiondef;
class relationdef;
class rule;
class logconst;
class equation;
class inequality;
class relsent;
class logsent;
class negation;
class implication;
class equivalence;
class disjunction;
class quantsent;
class universent;
class existensent;
class term;
class list;
class constant;
class indvar;
class string;
class funconst;
class relconst;
class objconst;
class listterm;
class setterm;
class functerm;
class quoterm;
class logterm;
class ifterm;
class kifnullobj;

extern char *typeName(kifobj *);
extern expression *kif_parse(int, const char *);

// External Functions Used By Inline Methods (in kifmethods.C)
extern char *listprint(char *s);
extern char *append(char *s1, char *s2);
extern sequence *seqappend(sequence *,sequence *);

// ************KIF Classes*******************

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---KIFOBJ
//Root Class for KIF Objects, Superclass of expressions
//and sequences.  Each kifobj class has an integer id which
//can be accessed via type.
//Superclasses:
//     kifobj
//Subclasses:
//     sequence
//     expression
//---------------------------
class kifobj {
 private:
  unsigned int type_id;
public:
  static const kifnullobj *nullmarker;
  virtual ~kifobj(void) {;}
  unsigned int type(void) {return type_id;}
  void settype(unsigned int i) {type_id = i;}
  virtual char *name(void) {return NULL;}
  virtual sequence *content(void) {return (sequence *) nullmarker;}
  virtual term *lhs(void) {return (term *) nullmarker;}
  virtual term *rhs(void) {return (term *) nullmarker;}
  virtual sentence *lhss(void) {return (sentence *) nullmarker;}
  virtual sentence *rhss(void) {return (sentence *) nullmarker;}
  virtual sequence *antecedent(void) {return (sequence *) nullmarker;}
  virtual sentence *consequent(void) {return (sentence *) nullmarker;}
  virtual sentence *sent(void) {return (sentence *) nullmarker;}
  virtual sequence *sents(void) {return (sequence *) nullmarker;}
  virtual sequence *varlist(void) {return (sequence *) nullmarker;}
  virtual term *relation(void) {return (term *) nullmarker;}
  virtual sequence *terms(void) {return (sequence *) nullmarker;}
  virtual unsigned int value(void) {return 0;}
  virtual expression *express(void) {return (expression *) nullmarker;}
  virtual sentence *testpart(void) {return (sentence *) nullmarker;}
  virtual term *thenpart(void) {return (term *) nullmarker;}
  virtual term *elsepart(void) {return (term *) nullmarker;}
  virtual term *func(void) {return (term *) nullmarker;}
  virtual term *object(void) {return (term *) nullmarker;}
  virtual sequence *freevariables(void) {return (sequence *) nullmarker;}
  virtual expression *hd(void) {return (expression *) nullmarker;}
  virtual sequence *tl(void) {return (sequence *) nullmarker;}
  virtual char *kifstring(void) {return strdup("");}
  void operator delete(void *p, size_t) {
    if (p!=nullmarker)
      ::delete p;
  }

};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---KIFNULLOBJ
//Superclasses:
//     expression
//Subclasses:
//---------------------------
class kifnullobj : public kifobj {
public:
  kifnullobj(void) {settype(KIFNULLOBJ);}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---EXPRESSION
//Superclasses:
//     kifobj
//Subclasses:
//     term
//     form
//     list
//     word
//---------------------------
class expression : public kifobj {
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---SEQUENCE
//Superclasses:
//     kifobj
//Subclasses:
//---------------------------
class sequence : public kifobj {
private:
  expression *head;
  sequence *tail;
public:
  sequence(expression *e) 
    /* The head of a sequence must be non-NULL */
    {settype(SEQUENCE);
     if (e!=NULL)
       head=e;
     else
       head= (expression *) nullmarker;
     tail= (sequence *) nullmarker;} 
  ~sequence(void) {
    delete head;delete tail;}
//    if (tail!=nullmarker)
//      delete tail;}
  expression *hd(void) {return head;}
  sequence *tl(void) {return tail;}
  int seqlength(void) 
    {int i=1;
     sequence *s=tail;
     while (s!=nullmarker && s!=NULL) 
       {s=s->tl();i++;} 
     return i;}
  void changetail(sequence *s) {tail = s;}
  void add(expression *e);
  sequence *freevariables(void) 
    {return(seqappend(hd()->freevariables(),
		      tl()->freevariables()));}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---TERM
//Superclasses:
//     expression
//Subclasses:
//     constant
//     functerm
//     listterm
//     setterm
//     quoterm
//     logterm
//     quanterm
//---------------------------
class term : public expression {
public:
  ~term(void) {;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---FORM
//Superclasses:
//     expression
//Subclasses:
//     sentence
//     rule
//     definition
//---------------------------
class form : public expression {
public:
  ~form(void) {;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---SENTENCE
//Superclasses:
//     form
//Subclasses:
//     logconst
//     equation
//     inequality
//     relsent
//     logsent
//     quantsent
//---------------------------
class sentence : public form {
public:
  ~sentence(void) {;}
};
//<>

class quanterm : public term {
};

class setofallterm : public quanterm {
  term *t;
  sentence *s;
 public:
  setofallterm(term* t1,sentence *s1) {
    settype(SETOFALLTERM);
    t = t1;
    s = s1;
  };
  ~setofallterm(){if(s) delete s; if (t) delete t;};
  term *target() { return(t);}
  sentence *setof_sentence() { return(s);}
  char *kifstring(void);
};

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---LIST
//Superclasses:
//     expression
//Subclasses:
//---------------------------
class list : public expression {
  sequence *seq;
 public:
  list(sequence *s) {settype(LIST);seq = s;}
  ~list(void)  {delete seq;}
  sequence *content(void) {return seq;}
  sequence *freevariables(void) 
    {return((content())?content()->freevariables():NULL);}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---WORD
//Superclasses:
//     expression
//Subclasses:
//---------------------------
class word : public expression {
 protected:
  char *val;
 public:
  ~word(void) {delete val;}
  char *name(void) {return val;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---CONSTANT
//Superclasses:
//     term
//Subclasses:
//     indvar
//     number
//     string
//     funconst
//     relconst
//     objconst
//---------------------------
class constant : public term {
 protected:
  char *con;
 public:
  ~constant(void) {delete con;}
  char *name(void) {return con;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---INDVAR
//Superclasses:
//     constant
//Subclasses:
//---------------------------
class indvar : public constant {
 public:
  indvar(char *c) {settype(INDVAR_);con=strdup(c);}
  ~indvar(void)  {delete con;}
  sequence *freevariables(void) 
    {sequence *seq = new sequence(this);return seq;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---NUMBER
//Superclasses:
//     constant
//Subclasses:
//---------------------------
class number : public constant {
 public:
  number(char *s) {settype(NUMBER_);con=strdup(s);};
  ~number(void)  {delete con;};
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---STRING
//Superclasses:
//     constant
//Subclasses:
//---------------------------
class string : public constant {
 public:
  string(char *s) {settype(STRING_);con=strdup(s);};
  ~string(void) {delete con;};
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---FUNCONST
//Superclasses:
//     constant
//Subclasses:
//---------------------------
class funconst : public constant {
 public:
  funconst(char *c) {settype(FUNCONST);con=strdup(c);}
  ~funconst(void)  {delete con;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---RELCONST
//Superclasses:
//     constant
//Subclasses:
//---------------------------
class relconst : public constant {
 public:
  relconst(char *c) {settype(RELCONST);con=strdup(c);}
  ~relconst(void)  {delete con;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---OBJCONST
//Superclasses:
//     constant
//Subclasses:
//---------------------------
class objconst : public constant {
 public:
  objconst(char *c) {settype(OBJCONST);con=strdup(c);}
  ~objconst(void)   {delete con;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---LISTTERM
//Superclasses:
//     term
//Subclasses:
//---------------------------
class listterm : public term {
  sequence *termsval;
 public:
  listterm(sequence *t) {settype(LISTTERM); termsval=t;}
  ~listterm(void)  {delete termsval;}
  sequence *terms(void) {return termsval;}
  sequence *freevariables(void) 
    {return((terms())?terms()->freevariables():NULL);}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---SETTERM
//Superclasses:
//     term
//Subclasses:
//---------------------------
class setterm : public term {
  sequence *termsval;
 public:
  setterm(sequence *t) {settype(SETTERM); termsval=t;}
  ~setterm(void)   {delete termsval;}
  sequence *terms(void) {return termsval;}
  sequence *freevariables(void) 
    {return((terms())?terms()->freevariables():NULL);}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---QUOTERM
//Superclasses:
//     term
//Subclasses:
//---------------------------
class quoterm : public term {
  expression *exp;
 public:
  quoterm(expression *e) {settype(QUOTERM); exp=e;}
  ~quoterm(void)  {delete exp;}
  expression *express(void) {return exp;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---LOGTERM
//Superclasses:
//     term
//Subclasses:
//     ifterm
//---------------------------
class logterm : public term {
public:
  ~logterm(void) {;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---IFTERM
//Superclasses:
//     logterm
//Subclasses:
//---------------------------
class ifterm : public logterm {
  sentence *s;
  term *term1,*term2;
 public:
  ifterm(sentence *s1,term *t1,term *t2)  
    {settype(IFTERM); s=s1; term1=t1; term2=t2;}
  ~ifterm(void) 
    {delete s; delete term1; delete term2;}
  sentence *testpart(void)  {return s;}
  term *thenpart(void)    {return term1;}
  term *elsepart(void)    {return term2;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---FUNCTERM
//Superclasses:
//     term
//Subclasses:
//---------------------------
class functerm : public term {
  funconst *funcon;
  sequence *termsval;
 public:
  functerm(funconst *con, sequence *tseq) 
    {settype(FUNCTERM);funcon=con; termsval=tseq;}
  ~functerm(void)  
    {delete funcon; delete termsval;}
  term *func(void)  {return funcon;}
  sequence *terms(void)  {return termsval;}
  sequence *freevariables(void) 
    {return((terms())?terms()->freevariables():NULL);}
  char *kifstring(void);
};
//<>


//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---EQUATION
//Superclasses:
//     sentence
//Subclasses:
//---------------------------
class equation : public sentence {
  term *term1,*term2;
 public:
  equation(term *t1, term *t2)  
    {settype(EQUATION);term1=t1; term2=t2;}
  ~equation(void)  {delete term1; delete term2;}
  term * lhs(void)      {return term1;}
  term * rhs(void)      {return term2;}
  sequence *freevariables(void) 
    {return(seqappend(lhs()->freevariables(),
		      rhs()->freevariables()));}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---INEQUALITY
//Superclasses:
//     sentence
//Subclasses:
//---------------------------
class inequality : public sentence {
  term *term1,*term2;
 public:
  inequality(term *t1, term *t2)  
    {settype(INEQUALITY);term1=t1; term2=t2;}
  ~inequality(void)  {delete term1; delete term2;}
  term * lhs(void)      {return term1;}
  term * rhs(void)      {return term2;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---LOGSENT
//Superclasses:
//     sentence
//Subclasses:
//     negation
//     conjunction
//     implication
//     disjunction
//     equivalence
//---------------------------
class logsent : public sentence {
public:
  ~logsent(void) {;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---NEGATION
//Superclasses:
//     logsent
//Subclasses:
//---------------------------
class negation : public logsent {
  sentence *senten;
 public:
  negation(sentence *s) {settype(NEGATION);senten=s;}
  ~negation(void)  {delete senten;}
  sentence *sent(void) {return senten;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---CONJUNCTION
//Superclasses:
//     logsent
//Subclasses:
//---------------------------
class conjunction : public logsent {
  sequence *sentseq;
 public:
  conjunction(sequence *s) 
    {settype(CONJUNCTION);sentseq=s;}
  ~conjunction(void)  {delete sentseq;}
  sequence *sents(void) {return sentseq;}
  sequence *freevariables(void) 
    {return(sents()->freevariables());}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---DISJUNCTION
//Superclasses:
//     logsent
//Subclasses:
//---------------------------
class disjunction : public logsent {
  sequence *sentseq;
 public:
  disjunction(sequence *s) 
    {settype(DISJUNCTION);sentseq=s;}
  ~disjunction(void)  {delete sentseq;}
  sequence *sents(void) {return sentseq;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---IMPLICATION
//Superclasses:
//     logsent
//Subclasses:
//---------------------------
class implication : public logsent {
  sequence *anteced;
  sentence *conseq;
 public:
  implication(sequence *sq, sentence *s) 
    {settype(IMPLICATION);anteced=sq;conseq=s;}
  ~implication(void)  {delete anteced; delete conseq;}
  sequence *antecedent(void) {return anteced;}
  sentence *consequent(void) {return conseq;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---EQUIVALENCE
//Superclasses:
//     logsent
//Subclasses:
//---------------------------
class equivalence : public logsent {
  sentence *sen1;
  sentence *sen2;
 public:
  equivalence(sentence *s1, sentence *s2) 
    {settype(EQUIVALENCE);sen1=s1;sen2=s2;}
  ~equivalence(void)  {delete sen1; delete sen2;}
  sentence *lhss(void) {return sen1;}
  sentence *rhss(void) {return sen2;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---QUANTSENT
//Superclasses:
//     sentence
//Subclasses:
//     universent
//     existensent
//---------------------------
class quantsent : public sentence {
 protected:
  sequence *vars;
  sentence *s;
 public:
public:
  ~quantsent(void) {delete vars;delete s;}
  sequence *varlist(void) {return vars;}
  sentence *sent(void) {return s;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---UNIVERSENT
//Superclasses:
//     quantsent
//Subclasses:
//---------------------------
class universent : public quantsent {
 public:
  universent(sequence *v, sentence *s1) 
    {settype(UNIVERSENT);vars=v; s=s1;}
  ~universent(void)  {delete vars; delete s;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---EXISTENSENT
//Superclasses:
//     quantsent
//Subclasses:
//---------------------------
class existensent : public quantsent {
 public:
  existensent(sequence *v, sentence *s1) 
    {settype(EXISTENSENT);vars=v; s=s1;}
  ~existensent(void)  {delete vars; delete s;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---RELSENT
//Superclasses:
//     sentence
//Subclasses:
//---------------------------
class relsent : public sentence {
  relconst *relcon;
  sequence *termsval;
 public:
  relsent(relconst *con, sequence *tseq) 
    {settype(RELSENT);relcon=con; termsval=tseq;}
  ~relsent(void)  {delete relcon; delete termsval;}
  term *relation(void)  {return relcon;}
  sequence *terms(void)  {return termsval;}
  sequence *freevariables(void) 
    {return((terms())?terms()->freevariables():NULL);}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---LOGCONST
//Superclasses:
//     sentence
//Subclasses:
//---------------------------
class logconst : public sentence {
  unsigned int val;
 public:
  logconst(unsigned int v) 
    {settype(LOGCONST); val=v;}
  unsigned int value(void) {return val;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---KIFOPERATOR
//Superclasses:
//     word
//Subclasses:
//     termop
//     sentop
//     defop
//     ruleop
//---------------------------
class kifoperator : public word {
public:
  ~kifoperator(void) {;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---TERMOP
//Superclasses:
//     kifoperator
//Subclasses:
//---------------------------
class termop : public kifoperator {
 public:
  termop(char *s) {settype(TERMOP);val=strdup(s);}
  ~termop(void)  {delete val;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---SENTOP
//Superclasses:
//     kifoperator
//Subclasses:
//---------------------------
class sentop : public kifoperator {
 public:
  sentop(char *s) {settype(SENTOP);val=strdup(s);}
  ~sentop(void)  {delete val;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---DEFOP
//Superclasses:
//     kifoperator
//Subclasses:
//---------------------------
class defop : public kifoperator {
 public:
  defop(char *s) {settype(DEFOP);val=strdup(s);}
  ~defop(void)  {delete val;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---RULEOP
//Superclasses:
//     kifoperator
//Subclasses:
//---------------------------
class ruleop : public kifoperator {
 public:
  ruleop(char *s) {settype(RULEOP);val=strdup(s);}
  ~ruleop(void)  {delete val;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---UKCONST
//Superclasses:
//     word
//Subclasses:
//---------------------------
class ukconst : public word {
 public:
  ukconst(char *s) {settype(UKCONST);val=strdup(s);}
  ~ukconst(void)  {delete val;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---CONSIS
//Superclasses:
//     expression
//Subclasses:
//---------------------------
class consis : public expression {
  sentence *s;
 public:
  consis(sentence *sen) {settype(CONSIS_);s=sen;}
  ~consis(void)  {delete s;}
  sentence *sent(void) {return s;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---DEFINITION
//Superclasses:
//     form
//Subclasses:
//     objectdef
//     functiondef
//     relationdef
//---------------------------
class definition : public form {
public:
  ~definition(void) {;}
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---OBJECTDEF
//Superclasses:
//     definition
//Subclasses:
//---------------------------
class objectdef : public definition {
  objconst *ob;
  term *ter;
 public:
  objectdef(objconst *o,term *t) 
    {settype(OBJECTDEF);ob=o;ter=t;}
  ~objectdef(void)  {delete ob; delete ter;}
  term *object(void) {return ob;}
  term *rhs(void) {return ter;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---FUNCTIONDEF
//Superclasses:
//     definition
//Subclasses:
//---------------------------
class functiondef : public definition {
  funconst *fun;
  sequence *vars;
  term *ter;
 public:
  functiondef(funconst *f,sequence *iv,term *t) 
    {settype(FUNCTIONDEF);fun=f;vars=iv;ter=t;}
  ~functiondef(void)  
    {delete fun; delete vars; delete ter;}
  term *func(void) {return fun;}
  sequence *varlist(void) {return vars;}
  term *rhs(void) {return ter;}
  char *kifstring(void);
};
//<>
  
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---RELATIONDEF
//Superclasses:
//     definition
//Subclasses:
//---------------------------
class relationdef : public definition {
  relconst *rel;
  sequence *vars;
  sentence *sen;
 public:
  relationdef(relconst *r,sequence *iv,sentence *s) 
    {settype(RELATIONDEF);rel=r;vars=iv;sen=s;}
  ~relationdef(void)
    {delete rel; delete vars; delete sen;}
  term *relation(void) {return rel;}
  sequence *varlist(void) {return vars;}
  sentence *rhss(void) {return sen;}
  char *kifstring(void);
};
//<>
  
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---RULE
//Superclasses:
//     form
//Subclasses:
//---------------------------
class rule : public form {
  sequence *prems;
  sentence *sen;
 public:
  rule(sequence *p,sentence *s) 
    {settype(RULE);prems=p;sen=s;}
  ~rule(void)  {delete prems; delete sen;}
  sequence *antecedent(void) {return prems;}
  sentence *consequent(void) {return sen;}
  char *kifstring(void);
};
//<>

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---SEQVAR
//Superclasses:
//     word
//Subclasses:
//---------------------------
class seqvar : public word {
 public:
  seqvar(char *s) {settype(SEQVAR_);val=strdup(s);}
  ~seqvar(void)  {delete val;}
};
//<>

#endif